2_Supervised_learning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2_Supervised_learning.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "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.7.6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mlukan/GDA3B2021/blob/main/2_Supervised_learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ka20bzp6PcNj"
      },
      "source": [
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Humboldt-WI/bads/blob/master/tutorials/5_nb_supervised_learning.ipynb) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "swSaDjWvNDnY"
      },
      "source": [
        "# Algorithms for supervised learning \n",
        "We revisit two popular algorithms for supervised learning, the logistic regression model and classification and regression trees (CART). We examine their mathematical and statistical underpinnings to fully understand how logit and CART craft a model. Of course, we also exemplify how to use both algorithms in practice together with `sklearn`.  \n",
        "\n",
        "The outline of the tutorial is as follows:\n",
        "- Logistic regression\n",
        "  - The logistic function\n",
        "  - Maximum likelihood estimation\n",
        "  - Logistic regression from scratch\n",
        "  - Libraries for logistic regression\n",
        "- Decision trees\n",
        "  - Implementing a tree algorithm from scratch\n",
        "  - Decision trees with `sklearn`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HjtJpOmnVf2K"
      },
      "source": [
        "# Logistic regression\n",
        "We learned from the lecture that the logistic model is the 'go-to model' for regression problems with a discrete target variable. Such problems are called classification problems. We can think of logit as the equivalent to linear regression for classification problem. Formally speaking, logistic regression belongs to the wider family of **generalized linear models (GLM)**. It is a generalization of a linear model in that it embodies the well-known linear form $\\beta x$ and adds a (non-linear) **link function** that connects the linear form to the target variable. In the case of logistic regression, the link function is the logistic function. Other GLMs use different link functions, but these are out of scope. So let us first examine the logistic function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k68aGAQ_Vf2L"
      },
      "source": [
        "## The logistic function\n",
        "We implement the logistic function as a custom Python function and then generate some data to plot the function over the interval from -4 to 4 [-4, -3, ..., 4]. \n",
        "Recall that the form of the function for input variable $z$ is $f(z) = \\frac{1}{1 + \\exp^{-z}}$. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "id": "xSZq_kegVf2L",
        "outputId": "c5597ed2-5c41-41c6-c844-3724c014ea39"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# we implement the logistic function as a custom function\n",
        "def logistic_fun(z):\n",
        "    return 1/(1+np.exp(-z))\n",
        "\n",
        "\n",
        "# create some data for plotting\n",
        "z = np.linspace(-4, 4)\n",
        "\n",
        "fz = logistic_fun(z)\n",
        "plt.title(\"The logistic function exemplified\", fontsize='small')\n",
        "plt.plot(z, fz);\n",
        "plt.plot(z, np.repeat(0.5, len(z)), \".\");  #  just for fun, add a horizontal line to highlight 0.5\n",
        "plt.ylabel(\"$f(z)$\")\n",
        "plt.xlabel(\"z\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'z')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        },
        {
          "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": "0QgT5fS6Vf2S"
      },
      "source": [
        "It is a good exercise to check how changes in the above implementation change the plot. For example, you could add a constant multiplier and calculate $e^{(-\\alpha z)} $ instead of $e^{(-z)}$, and check how the shape of the function changes with $\\alpha$. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gzDNTwuGVf2T"
      },
      "source": [
        "## Maximum likelihood estimation & gradient descent\n",
        "Estimating a logistic regression model involves minimizing the negative **log-likelihood** function. We discussed this in the lecture and experience suggests that some find this a little tough to digest, probably because of its level of formality. We will try to demystify the model by implementing it from scratch.  Maximum likelihood estimation (MLE) [link text](https://machinelearningmastery.com/logistic-regression-with-maximum-likelihood-estimation/) is a method of estimating the parameters $\\beta$ of a probability distribution by maximizing a likelihood function, so that under the assumed statistical model the observed data is most probable. The point in the parameter space that maximizes the likelihood function is called the maximum likelihood estimate. For starters, however, recall that logistic regression models the probability of observing a certain state of our target variable $y$ by means of the logistic function. We assume a zero-one coded binary target variable $y \\in {0, 1}$ and dependent on $\\beta_0+\\beta x$.  We can write the logit model as follows:\n",
        "\n",
        "$$ p \\left( y=1|x \\right) = \\frac{1}{1+e^{-z}}, \\text{  and  }  p \\left( y=0|x \\right) = 1- p \\left( y=1|x \\right) $$\n",
        "\n",
        "where $z$ is defined as a linear, additive function of the features: $z=\\hat{\\beta_0}+ \\hat{\\beta} x $. Assuming our data fulfills the IID assumption, we can write the log-likelihood function, see a [video here](www.youtube.com/watch?v=WflqTUOvdik) to get a more intuitive understanding of the formula: \n",
        "\n",
        "$$ \\mathcal{L_{1}} = \\sum^{n}_{i=1} \\left[ y_i \\log \\left(p \\left( y=1|x \\right) \\right) + \\left(1-y_i\\right) \\log \\left(1-p \\left( y=1|x \\right) \\right)\\right]. $$\n",
        "\n",
        "We need to now find the values of $ \\hat{\\beta} $ which maximizes this function. Maximizing the (log) likelihood is equivalent to minimizing the negative log likelihood, also referred to as  binary cross entropy loss:\n",
        "\n",
        "$$ \\mathcal{L} = - \\sum^{n}_{i=1} \\left[ y_i \\log \\left(p \\left( y=1|x \\right) \\right) + \\left(1-y_i\\right) \\log \\left(1-p \\left( y=1|x \\right) \\right)\\right]. $$\n",
        "\n",
        " There is literally no difference between the two objective functions, so there can be no difference between the resulting model or its characteristics. So we need to now find the values of $ \\hat{\\beta} $ which minimizes the negative log likelihood, so it will be necesssary to take its derivative. We will calculate the derivative of the log likelihood with respect to $ \\hat{\\beta_i} $. Essentially, we will have to calculate this using the chain rule:\n",
        "\n",
        "$$ \\frac{\\partial \\mathcal{L}}{\\partial \\hat{\\beta_i}} = \\frac{\\partial \\mathcal{L}}{\\partial p} \\cdot \\frac{\\partial p}{\\partial z} \\cdot \\frac{\\partial z}{\\partial \\hat{\\beta_i}} $$\n",
        "\n",
        "Let's first calculate the three derivatives which we will need on the right hand side:\n",
        "\n",
        "\\begin{align*} \n",
        "\\frac{\\partial \\mathcal{L}}{\\partial p} &= \\frac{y}{p} - \\frac{1-y}{1-p} \\\\\n",
        "\\frac{\\partial p}{\\partial z} &= \\frac{1}{1+e^{-z}} \\cdot  \\Bigg( 1 - \\frac{1}{1+e^{-z}} \\Bigg) = \\Big( p \\cdot  \\big( 1 - p \\big) \\Big) \\\\\n",
        "\\frac{\\partial z}{\\partial \\hat{\\beta_i}} &= x_i\n",
        "\\end{align*}\n",
        "\n",
        "\n",
        "Now we can multiply these three together to find the derivative of the log likelihood function with respect to $ \\hat{\\beta_i} $ :\n",
        " \n",
        "\\begin{align*}\n",
        " \\frac{\\partial \\mathcal{L}}{\\partial \\hat{\\beta_i}} &= \\frac{\\partial \\mathcal{L}}{\\partial p} \\cdot \\frac{\\partial p}{\\partial z} \\cdot \\frac{\\partial z}{\\partial \\hat{\\beta_i}} \\\\\n",
        " &= \\Big( \\frac{y}{p} - \\frac{1-y}{1-p} \\Big) \\cdot \\Big( p \\cdot  \\big( 1 - p \\big) \\Big) \\cdot x_i \\\\\n",
        " &= (y(1-p) - p(1-y)) \\cdot x_i \\\\ \n",
        " &= (y - p) \\cdot x_i\n",
        "\\end{align*}\n",
        "\n",
        "And voilà! At the end, we have a much simpler formula to deal with:\n",
        "$$ \\frac{\\partial \\mathcal{L}}{\\partial \\hat{\\beta_i}} = (y_i - p \\left( y=1|x_i \\right) ) \\cdot x_i $$\n",
        "\n",
        "In the most ideal world, we would be able to make an estimation $ \\hat{\\beta_i} $ for coefficients in our $ z $ function which would set this derivative to 0. However, this is not possible since the function is too complex. As such, we need to use another method. **Gradient descent** is the process of iteratively making changes to $ \\hat{\\beta_i} $ to assess which values lower the derivative value and, therefore, hopefully brings us closer to a minimum. Note that this may unfortunately **not be the global minimum of the function but rather a local minimum**. This is especially true if we have many coefficients or if any relationships are very complicated.\n",
        "\n",
        "Additionally, if we change $ \\hat{\\beta_i} $ by too much in one iteration, we may end up overshooting a minimum which is counterproductive. In order to avoid this, we **multiply the total difference by the learning rate** $ \\eta $ to dampen the update to $ \\hat{\\beta_i} $. If the learning rate is too low however, we may end up sabotaging ourselves as the function loses too much momentum in its updates. It is a good idea to experiment with a few different rates to see which one works best with your data.\n",
        "\n",
        "Here is an equation which represents gradient descent:\n",
        "$$ \\hat{\\beta_i} = \\hat{\\beta_{i-1}} - \\eta \\Delta( \\hat{\\beta_{i-1}}) \\text{ if } || \\hat{\\beta_i} - \\hat{\\beta_{i-1}} || > \\epsilon $$\n",
        "\n",
        "For an alternative explanation, check out the [Wikipedia page for *gradient descent*](https://en.wikipedia.org/wiki/Gradient_descent). It will be crucial for you to understand this process, so take advantage of online resources to improve your understanding. There are also many ways to modify this process like stochastic gradient descent or adaptive learning rates which you will undoubtedly come across later in the field."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I4JvbfcMVf2U",
        "outputId": "ae6799b5-9ef5-4ec7-9f2c-0d77a7553fcd"
      },
      "source": [
        "# Create synthetic data for classification using sklearn\n",
        "from sklearn.datasets import make_classification\n",
        "\n",
        "X, y = make_classification(n_features=2, n_redundant=0, n_informative=2, n_clusters_per_class=1, n_samples=500)\n",
        "\n",
        "# Always useful to remind oneself of the dimensions of a data set\n",
        "print(\"Shape of X {}\".format(X.shape))  \n",
        "print(\"Shape of y {}\".format(y.shape))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape of X (500, 2)\n",
            "Shape of y (500,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ETsdtRdkRLin"
      },
      "source": [
        "## Logistic Regression from scratch\n",
        "\n",
        "We can create a logistic regression function from scratch based on this [medium article](https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac). First, we need some data. To that end, we will use the approach for synthetic data creation . The following code wraps up the data creation in a custom function. Alternatively, we could have used the function `make_classification` from `sklearn`. We like our approach a little better but feel most free to change the data generation approach and try out the example using the [`sklearn` data.](https://scikit-learn.org/stable/datasets/toy_dataset.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PWv60eLVDmyT"
      },
      "source": [
        "### Synthetic data generation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4a3k8dKQWIx4"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7O1rqLbODmyT"
      },
      "source": [
        "def toy_data(n=1000, mu1=[1,1], mu2=[4, 4], sig1=1, sig2=1):\n",
        "    \"\"\" Customer function to generate linearly seperable toy data.\n",
        "        \n",
        "        The arguments represent, respectively, the size of the data, the mean vectors of the two Gaussians from which we\n",
        "        sample class 1 and class 2 data points, and their standard deviations.\n",
        "    \"\"\"\n",
        "    \n",
        "    class1_x1 = np.random.normal(loc=mu1[0], scale=sig1, size=n)\n",
        "    class1_x2 = np.random.normal(loc=mu1[1], scale=sig1, size=n)\n",
        "\n",
        "    class2_x1 = np.random.normal(loc=mu2[0], scale=sig2, size=n)\n",
        "    class2_x2 = np.random.normal(loc=mu2[1], scale=sig2, size=n)\n",
        "\n",
        "    y1 = np.repeat(0, n)\n",
        "    y2 = np.repeat(1, n)\n",
        "\n",
        "    class1 = np.vstack((class1_x1, class1_x2)).T\n",
        "    class2 = np.vstack((class2_x1, class2_x2)).T\n",
        "\n",
        "    X = np.vstack((class1,class2))\n",
        "    y = np.concatenate((y1,y2))\n",
        "    \n",
        "    return X, y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ym5oBSTDmyX",
        "outputId": "7d0dcefa-a643-46e0-8b10-196fc886a32b"
      },
      "source": [
        "# Create and plot the data\n",
        "X, y = toy_data()\n",
        "\n",
        "# Always useful to remind oneself of the dimensions of a data set\n",
        "print(\"Shape of X {}\".format(X.shape))  \n",
        "print(\"Shape of y {}\".format(y.shape))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape of X (2000, 2)\n",
            "Shape of y (2000,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 278
        },
        "id": "gFoMDi41Vf2b",
        "outputId": "d39a2c85-51a4-46e2-df85-51f806340186"
      },
      "source": [
        "# Here is the code to plot the data\n",
        "plt.title(\"Synthetic classification data set\", fontsize='small')\n",
        "plt.scatter(X[:, 0], X[:, 1], c=y, alpha=.5, marker='x');"
      ],
      "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": "gqBHE9146JjJ"
      },
      "source": [
        "### Helper function for the logit model\n",
        "We already defined the logistic function. We do it again to have all codes at a single space. This is only to aid readability. Note that data scientists very commonly refer to the logistic function as the **sigmoid**. The name relates to a class of learning machines called *artificial neural networks*, which are the backbone of deep learning. We use this term below, simply because it is sooo common and because we already used the logistic function for our above implementation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eYv3EuJVu90F"
      },
      "source": [
        "def sigmoid(z):\n",
        "    return 1 / (1 + np.exp(-z))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kWMS3zIE6ahA"
      },
      "source": [
        "We also need a loss function whose gradient we will determine which way to adjust parameters. Essentially, this is just our log-likelihood function. Easy enough to implement it in Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pg0Zn7OywTFH"
      },
      "source": [
        "def loss(h, y):\n",
        "    return (-y*np.log(h) - (1 - y)*np.log(1 - h))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oud8yNf1V_i_"
      },
      "source": [
        "Equipped with the previous functions, we are ready to implement logistic regression. More specifically, the below function takes care about **estimating a logistic regression model**. It determines and returns the weights (intercept and coefficients), which represent the logit model, as an 1D array. Remember that these weights are all we need to generate predictions for future data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0k3PuDa9YDyL"
      },
      "source": [
        "def estimate_logit_model(X, y, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):\n",
        "    \n",
        "    # Add intercept to the model if needed\n",
        "    if fit_intercept:\n",
        "      intercept = np.ones((X.shape[0], 1))\n",
        "      X = np.concatenate((intercept, X), axis=1)\n",
        "        \n",
        "    weights = np.zeros(X.shape[1]) # initialize weights\n",
        "    \n",
        "    for i in range(num_iter): # travels down the gradient as many times as there are iterations\n",
        "        z = np.dot(X, weights)\n",
        "        h = sigmoid(z)\n",
        "        gradient = np.dot(X.T, (h - y)) / y.size\n",
        "        weights -= lr * gradient\n",
        "            \n",
        "    if(verbose == True and i % 10000 == 0): # checks loss at each iteration\n",
        "        z = np.dot(X, weights)\n",
        "        h = sigmoid(z)\n",
        "        loss_val = loss(h, y)\n",
        "        print(f'loss: {loss_val} \\t')\n",
        "    return weights"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ruq6ZopYC-jc"
      },
      "source": [
        "Lastly, we need some functionality for predicting probabilities for new data points. To replicate standard functionality of `sklean` in our custom logit model, we will supply two functions for prediction. Naturally, the logit model generates probabilistic predictions, which follows from using the sigmoid (aka logistic) function. Further, we supply a sklearn-like `predict()` function, which returns discrete class predictions using some **cut-off**, which we set to 0.5 by default. We can then compare this predicted value to the true labels and calculate the mean error or mean accuracy. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d3pGMkA5uS3J"
      },
      "source": [
        "def predict_prob(X, weights, fit_intercept=True):\n",
        "    if fit_intercept:\n",
        "        intercept = np.ones((X.shape[0], 1))\n",
        "        X = np.concatenate((intercept, X), axis=1)\n",
        "        return sigmoid(np.dot(X, weights))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmySMlJvxN1T"
      },
      "source": [
        "def predict(X, weights, fit_intercept=True, threshold=0.5):\n",
        "    predictions = predict_prob(X, weights, fit_intercept=fit_intercept) >= threshold\n",
        "    predictions = np.where(predictions==False, 0, predictions)\n",
        "    predictions = np.where(predictions==True, 1, predictions)\n",
        "    return predictions"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CQwxEi9D1Qtn"
      },
      "source": [
        "Now we can train our model on the data that we have generated to get the intercept (first number in the weights array) and coefficients (the subsequent numbers in the array). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LiW-bUPf5c1Q"
      },
      "source": [
        "beta = estimate_logit_model(X, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6SCqiUuuiTYH",
        "outputId": "1975bf08-4f0c-4bbb-dcb2-6638652db160"
      },
      "source": [
        "print(beta)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-10.59642991   2.2236904    2.17395292]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9dL4NVcq4K_C"
      },
      "source": [
        "Ok, does maybe not look exciting but, believe it or not, these three numbers are our **logit model**. Really? Yes. All you need to calculate forecasts from a logistic regression models is the coefficients, one for each feature and one for the intercept. For our toy data, this translates into three numbers. \n",
        "\n",
        "All set, we are ready to put our model into production and estimate, for each case in our data, the probabilities of that case belonging to class 1. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QBMwMlJyEl6S",
        "outputId": "f0de9622-2a1d-4891-fa60-5b5ca5ca0b75"
      },
      "source": [
        "# This is how we produce class membership probabilities\n",
        "results = predict_prob(X, beta, fit_intercept=True)\n",
        "print(results[:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3.86917537e-05 1.20429673e-05 6.63866627e-01 9.55794809e-02\n",
            " 1.35224731e-06]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0p2TkHAErH7P",
        "outputId": "e9647d84-84b4-433b-bd9f-856e8d297478"
      },
      "source": [
        "# And in this way, we can generate discrete class predictions\n",
        "results = predict(X, beta, fit_intercept=True, threshold=0.5)\n",
        "print(results[:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 0 1 0 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S3Ivh9cxrmEr",
        "outputId": "0579bd8a-8776-48a7-f1f3-8d9d0471d08a"
      },
      "source": [
        "# Let's check the classification accuracy of our logit model\n",
        "accuracy = y == results\n",
        "\n",
        "mean_accuracy = accuracy.sum() / len(accuracy)\n",
        "\n",
        "mean_accuracy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9855"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CP6HSAeg4oX3"
      },
      "source": [
        "To conclude this example, recall that we introduced logistic regression as a linear classifier in the lecture. To convince ourselves that logit really creates a linear decision boundary, we plot this boundary into our feature space using the intercept found in `beta[0]` and the two coefficients found in `beta[1]` and `beta[2]`. \n",
        "\n",
        " In a two-dimensional space, with dimensions $(x_1, x_2)$, a hyperplane is defined by $\\beta_1 x_1 + \\beta_2 x_2 + \\beta_0 = 0$. Rearranging terms, we obtain \n",
        " $$ x_2 = - \\frac{\\beta_1}{\\beta_2} x_1 - \\frac{\\beta_0}{\\beta_2} $$\n",
        " \n",
        " Actually, this equation looks a little odd at first glance. We are used to think of $\\mathbf{x}$ as data. So why is $x_2$ a function? Well, the equation simply gives as a blueprint of hot to plot the hyperplane in 2D. We generate some data for $x_1$. Next, using the estimated values for $\\mathbf{\\beta}$, we determine the corresponding value of $x_2$. This is only to facilitate drawing as follows: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y_YXW7Y2dmAu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80831af3-d58d-40ba-8293-5b39dd9ee7bb"
      },
      "source": [
        "# Generate data points\n",
        "x_1 = np.linspace(-3, 8)  # we plot the hyperplane for this range of values\n",
        "\n",
        "x_2 = - beta[1] / beta[2] * x_1 - beta[0] / beta[2]  # evaluate our above equation\n",
        "\n",
        "# Ready to plot our hyperplane\n",
        "fig = plt.figure()\n",
        "plt.plot(x_1,x_2, label='logit');\n",
        "plt.xlabel(\"$x_1$\");\n",
        "plt.ylabel(\"$x_2$\");\n",
        "plt.legend(loc='best');\n",
        "# Add the actual data to the plot (as before)\n",
        "plt.scatter(X[:,0], X[:,1], c=y, alpha=.5, marker='x');"
      ],
      "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": "TV266MtlAR3i",
        "outputId": "c18a11a5-ace7-476c-858c-b3795e27ea79"
      },
      "source": [
        "Looks good. Using the estimated parameters and drawing a line using these parameters, the plot confirms that we obtain a good separation of the two classes. And yet, we can create a better visualization in which we also evaluate the probability estimates of our model. So in case you missed the logistic function is the above example, no worries, we are getting there. To that end, we will compute the output (i.e., probability estimate) of our logit model over the entire feature space. More precisely, we decide on a value range for $x_1$ and $x_2$ and consider all possible input data points in that range. The resulting data is three dimensional and consists of tupels $\\left( x_{i1}, x_{i2}, p_i \\right)$, where $i$ is a data point index and $p_i$ is the probability forecast from the logit model for data point $\\mathbf{x}_i$. Plotting in three dimensions in nontrivial. Below, we provide a working example for generating and plotting the data. The plot offers a maybe more accurate intuition on the inner workings of the logistic model and how it creates a linear classifier. Parts of the code will be hard to read. Feel free to just skip over them and look at the result (i.e., plot). If you want to understand what is going on, start with reading the documentation of the NumPy function `mgrid()`, look up demos for contour plots, and, of course, debug/alter the example in any way you like. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5HePiSyOdmAu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45095714-cb4a-406b-fcbf-26d045cfd802"
      },
      "source": [
        "# Graph to depict probability predictions of the logit model\n",
        "\n",
        "xx, yy = np.mgrid[-3:8:.01, -3:8:.01]  # create input data for our logit model using mgrid\n",
        "grid = np.c_[xx.ravel(), yy.ravel()]   # then transform the data into our standard format\n",
        "\n",
        "# Calculate logit probability predictions\n",
        "probs = predict_prob(grid, beta, fit_intercept=True)\n",
        "\n",
        "# Reshape to facilitate plotting\n",
        "probs = probs.reshape(xx.shape)\n",
        "\n",
        "# Plot logit predictions\n",
        "f, ax = plt.subplots(figsize=(8, 6))\n",
        "contour = ax.contourf(xx, yy, probs, 25,  vmin=0, vmax=1)\n",
        "ax_c = f.colorbar(contour)\n",
        "ax_c.set_label(\"$P(y = 1)$\")\n",
        "ax_c.set_ticks([0, .25, .5, .75, 1])\n",
        "\n",
        "# Plott the actual data points\n",
        "# We alter the format of the scatter plot to ensure that data points are visible\n",
        "ax.scatter(X[:,0], X[:,1], c=y, s=50, vmin=-.2, vmax=1.2, edgecolor=\"white\", linewidth=1);  \n",
        "plt.xlabel(\"$x_1$\");\n",
        "plt.ylabel(\"$x_2$\");"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HUkvWfFsVf2m"
      },
      "source": [
        "## Libraries for logistic regression\n",
        "\n",
        "Now that we know that estimating a logistic regression model using the maximum likelihood approach is not some sort of dark magic, we might feel more comfortable with using libraries that hide all the details. In fact, one such library that can be used is the `statsmodels` library to estimate a logit model. However, doing so for our toy data is pointless. It's time for a real-world data set and since we spent so much time on cleaning and preparing and understanding the HMEQ data in the previous notebook, it would be a shame to not use it for demonstrating logistic regression on some real data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lJeLRJrBax-R",
        "outputId": "3991bcb8-4af4-4b2a-bf5e-b981c86b51dd"
      },
      "source": [
        "#Mount the Google Drive to be able to upload the files stored in Google Drive in our Colab Notebooks:\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dkKRcRBRVf2n"
      },
      "source": [
        "import pandas as pd \n",
        "import statsmodels.api as sm\n",
        "from statsmodels.tools.tools import add_constant\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PLQ7buLVf2q"
      },
      "source": [
        "Let's take a quick look at the data to re-familiarize ourselves with the classification task."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Wkn0wsPiy9n"
      },
      "source": [
        "path=\"/content/drive/My Drive/Colab Notebooks/WCS/hmeq_prepared.csv\"\n",
        "# Import data\n",
        "#data_url = path\n",
        "df = pd.read_csv(path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 427
        },
        "id": "w7OnomMJjX10",
        "outputId": "9d62fc2f-38f7-458e-f6fa-26e4f6097fb2"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "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>BAD</th>\n",
              "      <th>LOAN</th>\n",
              "      <th>MORTDUE</th>\n",
              "      <th>VALUE</th>\n",
              "      <th>REASON</th>\n",
              "      <th>JOB</th>\n",
              "      <th>YOJ</th>\n",
              "      <th>DEROG</th>\n",
              "      <th>DELINQ</th>\n",
              "      <th>CLAGE</th>\n",
              "      <th>NINQ</th>\n",
              "      <th>CLNO</th>\n",
              "      <th>DEBTINC</th>\n",
              "      <th>DELINQcat</th>\n",
              "      <th>DEROGzero</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>True</td>\n",
              "      <td>1100.0</td>\n",
              "      <td>25860.0</td>\n",
              "      <td>39025.0</td>\n",
              "      <td>HomeImp</td>\n",
              "      <td>Other</td>\n",
              "      <td>10.5</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>94.366670</td>\n",
              "      <td>1.0</td>\n",
              "      <td>9.0</td>\n",
              "      <td>34.818260</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>True</td>\n",
              "      <td>1300.0</td>\n",
              "      <td>70053.0</td>\n",
              "      <td>68400.0</td>\n",
              "      <td>HomeImp</td>\n",
              "      <td>Other</td>\n",
              "      <td>7.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.0</td>\n",
              "      <td>121.833336</td>\n",
              "      <td>0.0</td>\n",
              "      <td>14.0</td>\n",
              "      <td>34.818260</td>\n",
              "      <td>1+</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>True</td>\n",
              "      <td>1500.0</td>\n",
              "      <td>13500.0</td>\n",
              "      <td>16700.0</td>\n",
              "      <td>HomeImp</td>\n",
              "      <td>Other</td>\n",
              "      <td>4.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>149.466660</td>\n",
              "      <td>1.0</td>\n",
              "      <td>10.0</td>\n",
              "      <td>34.818260</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>True</td>\n",
              "      <td>1500.0</td>\n",
              "      <td>65019.0</td>\n",
              "      <td>89235.5</td>\n",
              "      <td>IsMissing</td>\n",
              "      <td>Other</td>\n",
              "      <td>7.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>173.466660</td>\n",
              "      <td>1.0</td>\n",
              "      <td>20.0</td>\n",
              "      <td>34.818260</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>False</td>\n",
              "      <td>1700.0</td>\n",
              "      <td>97800.0</td>\n",
              "      <td>112000.0</td>\n",
              "      <td>HomeImp</td>\n",
              "      <td>Office</td>\n",
              "      <td>3.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>93.333336</td>\n",
              "      <td>0.0</td>\n",
              "      <td>14.0</td>\n",
              "      <td>34.818260</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5955</th>\n",
              "      <td>False</td>\n",
              "      <td>59900.0</td>\n",
              "      <td>57264.0</td>\n",
              "      <td>90185.0</td>\n",
              "      <td>DebtCon</td>\n",
              "      <td>Other</td>\n",
              "      <td>16.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>221.808720</td>\n",
              "      <td>0.0</td>\n",
              "      <td>16.0</td>\n",
              "      <td>36.112347</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5956</th>\n",
              "      <td>False</td>\n",
              "      <td>59900.0</td>\n",
              "      <td>54576.0</td>\n",
              "      <td>92937.0</td>\n",
              "      <td>DebtCon</td>\n",
              "      <td>Other</td>\n",
              "      <td>16.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>208.692060</td>\n",
              "      <td>0.0</td>\n",
              "      <td>15.0</td>\n",
              "      <td>35.859970</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5957</th>\n",
              "      <td>False</td>\n",
              "      <td>59900.0</td>\n",
              "      <td>54045.0</td>\n",
              "      <td>92924.0</td>\n",
              "      <td>DebtCon</td>\n",
              "      <td>Other</td>\n",
              "      <td>15.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>212.279700</td>\n",
              "      <td>0.0</td>\n",
              "      <td>15.0</td>\n",
              "      <td>35.556590</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5958</th>\n",
              "      <td>False</td>\n",
              "      <td>59900.0</td>\n",
              "      <td>50370.0</td>\n",
              "      <td>91861.0</td>\n",
              "      <td>DebtCon</td>\n",
              "      <td>Other</td>\n",
              "      <td>14.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>213.892720</td>\n",
              "      <td>0.0</td>\n",
              "      <td>16.0</td>\n",
              "      <td>34.340880</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5959</th>\n",
              "      <td>False</td>\n",
              "      <td>59900.0</td>\n",
              "      <td>48811.0</td>\n",
              "      <td>88934.0</td>\n",
              "      <td>DebtCon</td>\n",
              "      <td>Other</td>\n",
              "      <td>15.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>219.601000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>16.0</td>\n",
              "      <td>34.571518</td>\n",
              "      <td>0</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>5960 rows × 15 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "        BAD     LOAN  MORTDUE     VALUE  ...  CLNO    DEBTINC  DELINQcat  DEROGzero\n",
              "0      True   1100.0  25860.0   39025.0  ...   9.0  34.818260          0       True\n",
              "1      True   1300.0  70053.0   68400.0  ...  14.0  34.818260         1+       True\n",
              "2      True   1500.0  13500.0   16700.0  ...  10.0  34.818260          0       True\n",
              "3      True   1500.0  65019.0   89235.5  ...  20.0  34.818260          0       True\n",
              "4     False   1700.0  97800.0  112000.0  ...  14.0  34.818260          0       True\n",
              "...     ...      ...      ...       ...  ...   ...        ...        ...        ...\n",
              "5955  False  59900.0  57264.0   90185.0  ...  16.0  36.112347          0       True\n",
              "5956  False  59900.0  54576.0   92937.0  ...  15.0  35.859970          0       True\n",
              "5957  False  59900.0  54045.0   92924.0  ...  15.0  35.556590          0       True\n",
              "5958  False  59900.0  50370.0   91861.0  ...  16.0  34.340880          0       True\n",
              "5959  False  59900.0  48811.0   88934.0  ...  16.0  34.571518          0       True\n",
              "\n",
              "[5960 rows x 15 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 237
        },
        "id": "-lqqkeXgixW6",
        "outputId": "02347658-f49b-4160-815a-b5f488203149"
      },
      "source": [
        "# dummy coding of categoorical var JOB, REASON,\tDELINQcat  using `get_dummies()`\n",
        "# Documentation: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.get_dummies.html\n",
        "\n",
        "df_prep = pd.get_dummies(df, columns = ['REASON','JOB','DELINQcat'])\n",
        "print(df_prep.shape)\n",
        "df_prep.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5960, 24)\n"
          ],
          "name": "stdout"
        },
        {
          "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>BAD</th>\n",
              "      <th>LOAN</th>\n",
              "      <th>MORTDUE</th>\n",
              "      <th>VALUE</th>\n",
              "      <th>YOJ</th>\n",
              "      <th>DEROG</th>\n",
              "      <th>DELINQ</th>\n",
              "      <th>CLAGE</th>\n",
              "      <th>NINQ</th>\n",
              "      <th>CLNO</th>\n",
              "      <th>DEBTINC</th>\n",
              "      <th>DEROGzero</th>\n",
              "      <th>REASON_DebtCon</th>\n",
              "      <th>REASON_HomeImp</th>\n",
              "      <th>REASON_IsMissing</th>\n",
              "      <th>JOB_Mgr</th>\n",
              "      <th>JOB_Office</th>\n",
              "      <th>JOB_Other</th>\n",
              "      <th>JOB_ProfExe</th>\n",
              "      <th>JOB_Sales</th>\n",
              "      <th>JOB_Self</th>\n",
              "      <th>DELINQcat_0</th>\n",
              "      <th>DELINQcat_1</th>\n",
              "      <th>DELINQcat_1+</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>True</td>\n",
              "      <td>1100.0</td>\n",
              "      <td>25860.0</td>\n",
              "      <td>39025.0</td>\n",
              "      <td>10.5</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>94.366670</td>\n",
              "      <td>1.0</td>\n",
              "      <td>9.0</td>\n",
              "      <td>34.81826</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>True</td>\n",
              "      <td>1300.0</td>\n",
              "      <td>70053.0</td>\n",
              "      <td>68400.0</td>\n",
              "      <td>7.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.0</td>\n",
              "      <td>121.833336</td>\n",
              "      <td>0.0</td>\n",
              "      <td>14.0</td>\n",
              "      <td>34.81826</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>True</td>\n",
              "      <td>1500.0</td>\n",
              "      <td>13500.0</td>\n",
              "      <td>16700.0</td>\n",
              "      <td>4.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>149.466660</td>\n",
              "      <td>1.0</td>\n",
              "      <td>10.0</td>\n",
              "      <td>34.81826</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>True</td>\n",
              "      <td>1500.0</td>\n",
              "      <td>65019.0</td>\n",
              "      <td>89235.5</td>\n",
              "      <td>7.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>173.466660</td>\n",
              "      <td>1.0</td>\n",
              "      <td>20.0</td>\n",
              "      <td>34.81826</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>False</td>\n",
              "      <td>1700.0</td>\n",
              "      <td>97800.0</td>\n",
              "      <td>112000.0</td>\n",
              "      <td>3.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>93.333336</td>\n",
              "      <td>0.0</td>\n",
              "      <td>14.0</td>\n",
              "      <td>34.81826</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     BAD    LOAN  MORTDUE  ...  DELINQcat_0  DELINQcat_1  DELINQcat_1+\n",
              "0   True  1100.0  25860.0  ...            1            0             0\n",
              "1   True  1300.0  70053.0  ...            0            0             1\n",
              "2   True  1500.0  13500.0  ...            1            0             0\n",
              "3   True  1500.0  65019.0  ...            1            0             0\n",
              "4  False  1700.0  97800.0  ...            1            0             0\n",
              "\n",
              "[5 rows x 24 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QjbPLXzqqbYP"
      },
      "source": [
        "#drop columns DELINQ, DEROG, REASON_DebtCon, JOB_Mgr, DELINQcat_0 to make sure we do not have correlated variables (Multcolinearity assumption) \n",
        "df_prep =df_prep.drop(columns=['DELINQ', 'DEROG', 'REASON_DebtCon', 'JOB_Mgr', 'DELINQcat_0'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zeWB1C5qpNX3"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "#Scale the numeric values with the Standard Scaler\n",
        "#Note the proper application of the scaler: fitting parameters on train and apply these to test\n",
        "#This is the standart procedure to scale. You always learn your scaling parameters on the train and then use them on the test. Otherwise you incorporate information from test data into the training process. This article explains it very well:https://sebastianraschka.com/faq/docs/scale-training-test.html\n",
        "scaler = StandardScaler()\n",
        "df_prep[['LOAN', 'MORTDUE', 'VALUE', 'YOJ', 'CLAGE','NINQ', 'CLNO', 'DEBTINC']] = scaler.fit_transform(df_prep[['LOAN', 'MORTDUE', 'VALUE', 'YOJ', 'CLAGE','NINQ', 'CLNO', 'DEBTINC']])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 427
        },
        "id": "4Im6_FsCzB-h",
        "outputId": "6fb8aa6c-fb19-4ba3-aca3-41a04359b3e5"
      },
      "source": [
        "df_prep"
      ],
      "execution_count": null,
      "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>BAD</th>\n",
              "      <th>LOAN</th>\n",
              "      <th>MORTDUE</th>\n",
              "      <th>VALUE</th>\n",
              "      <th>YOJ</th>\n",
              "      <th>CLAGE</th>\n",
              "      <th>NINQ</th>\n",
              "      <th>CLNO</th>\n",
              "      <th>DEBTINC</th>\n",
              "      <th>DEROGzero</th>\n",
              "      <th>REASON_HomeImp</th>\n",
              "      <th>REASON_IsMissing</th>\n",
              "      <th>JOB_Office</th>\n",
              "      <th>JOB_Other</th>\n",
              "      <th>JOB_ProfExe</th>\n",
              "      <th>JOB_Sales</th>\n",
              "      <th>JOB_Self</th>\n",
              "      <th>DELINQcat_1</th>\n",
              "      <th>DELINQcat_1+</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.653277</td>\n",
              "      <td>-1.178335</td>\n",
              "      <td>-1.214631</td>\n",
              "      <td>0.240519</td>\n",
              "      <td>-1.048118</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-1.235873</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.634229</td>\n",
              "      <td>-0.057653</td>\n",
              "      <td>-0.634500</td>\n",
              "      <td>-0.241941</td>\n",
              "      <td>-0.708023</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.730854</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.615181</td>\n",
              "      <td>-1.491770</td>\n",
              "      <td>-1.655531</td>\n",
              "      <td>-0.655479</td>\n",
              "      <td>-0.365865</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-1.134869</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.615181</td>\n",
              "      <td>-0.185310</td>\n",
              "      <td>-0.223017</td>\n",
              "      <td>-0.241941</td>\n",
              "      <td>-0.068694</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-0.124831</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>False</td>\n",
              "      <td>-1.596133</td>\n",
              "      <td>0.645978</td>\n",
              "      <td>0.226563</td>\n",
              "      <td>-0.793325</td>\n",
              "      <td>-1.060913</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.730854</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5955</th>\n",
              "      <td>False</td>\n",
              "      <td>3.946796</td>\n",
              "      <td>-0.381967</td>\n",
              "      <td>-0.204265</td>\n",
              "      <td>0.998671</td>\n",
              "      <td>0.529882</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.528846</td>\n",
              "      <td>0.333903</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5956</th>\n",
              "      <td>False</td>\n",
              "      <td>3.946796</td>\n",
              "      <td>-0.450132</td>\n",
              "      <td>-0.149915</td>\n",
              "      <td>0.998671</td>\n",
              "      <td>0.367470</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.629850</td>\n",
              "      <td>0.295475</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5957</th>\n",
              "      <td>False</td>\n",
              "      <td>3.946796</td>\n",
              "      <td>-0.463597</td>\n",
              "      <td>-0.150172</td>\n",
              "      <td>0.860825</td>\n",
              "      <td>0.411893</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.629850</td>\n",
              "      <td>0.249282</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5958</th>\n",
              "      <td>False</td>\n",
              "      <td>3.946796</td>\n",
              "      <td>-0.556791</td>\n",
              "      <td>-0.171165</td>\n",
              "      <td>0.722980</td>\n",
              "      <td>0.431865</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.528846</td>\n",
              "      <td>0.064174</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5959</th>\n",
              "      <td>False</td>\n",
              "      <td>3.946796</td>\n",
              "      <td>-0.596325</td>\n",
              "      <td>-0.228971</td>\n",
              "      <td>0.860825</td>\n",
              "      <td>0.502546</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.528846</td>\n",
              "      <td>0.099292</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>5960 rows × 19 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "        BAD      LOAN   MORTDUE  ...  JOB_Self  DELINQcat_1  DELINQcat_1+\n",
              "0      True -1.653277 -1.178335  ...         0            0             0\n",
              "1      True -1.634229 -0.057653  ...         0            0             1\n",
              "2      True -1.615181 -1.491770  ...         0            0             0\n",
              "3      True -1.615181 -0.185310  ...         0            0             0\n",
              "4     False -1.596133  0.645978  ...         0            0             0\n",
              "...     ...       ...       ...  ...       ...          ...           ...\n",
              "5955  False  3.946796 -0.381967  ...         0            0             0\n",
              "5956  False  3.946796 -0.450132  ...         0            0             0\n",
              "5957  False  3.946796 -0.463597  ...         0            0             0\n",
              "5958  False  3.946796 -0.556791  ...         0            0             0\n",
              "5959  False  3.946796 -0.596325  ...         0            0             0\n",
              "\n",
              "[5960 rows x 19 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8W8RaVkr0r9K"
      },
      "source": [
        "df=df_prep"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S_b8UOuPVf2x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "844d6551-b8c3-4137-b54b-d18af2a2b3d7"
      },
      "source": [
        "# Split into target and features\n",
        "y = df.BAD.values.astype(int)\n",
        "X = df.iloc[:,1:]\n",
        "\n",
        "# We add a constant column to X. Think of this as the Python way to include an intercept in your model \n",
        "X = add_constant(X, prepend=True, has_constant='raise')\n",
        "# Estimate logit model\n",
        "logit_model = sm.Logit(y, X.astype(float), ) \n",
        "logit_model = logit_model.fit()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Optimization terminated successfully.\n",
            "         Current function value: 0.394990\n",
            "         Iterations 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m3_inlDcVf21"
      },
      "source": [
        "A nice feature of the `statsmodels` implementation is that you can easily produce a standard regression table. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C0k55AmTVf21",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 603
        },
        "outputId": "7219d60e-9572-4e8e-c1c6-2f5b2e5b7394"
      },
      "source": [
        "logit_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<table class=\"simpletable\">\n",
              "<caption>Logit Regression Results</caption>\n",
              "<tr>\n",
              "  <th>Dep. Variable:</th>           <td>y</td>        <th>  No. Observations:  </th>   <td>  5960</td>  \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>Model:</th>                 <td>Logit</td>      <th>  Df Residuals:      </th>   <td>  5941</td>  \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>Method:</th>                 <td>MLE</td>       <th>  Df Model:          </th>   <td>    18</td>  \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>Date:</th>            <td>Wed, 05 May 2021</td> <th>  Pseudo R-squ.:     </th>   <td>0.2096</td>  \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>Time:</th>                <td>23:18:01</td>     <th>  Log-Likelihood:    </th>  <td> -2354.1</td> \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>converged:</th>             <td>True</td>       <th>  LL-Null:           </th>  <td> -2978.2</td> \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>Covariance Type:</th>     <td>nonrobust</td>    <th>  LLR p-value:       </th> <td>5.257e-254</td>\n",
              "</tr>\n",
              "</table>\n",
              "<table class=\"simpletable\">\n",
              "<tr>\n",
              "          <td></td>            <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
              "</tr>\n",
              "<tr>\n",
              "  <th>const</th>            <td>   -1.1373</td> <td>    0.134</td> <td>   -8.494</td> <td> 0.000</td> <td>   -1.400</td> <td>   -0.875</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>LOAN</th>             <td>   -0.1692</td> <td>    0.043</td> <td>   -3.922</td> <td> 0.000</td> <td>   -0.254</td> <td>   -0.085</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>MORTDUE</th>          <td>   -0.1588</td> <td>    0.068</td> <td>   -2.321</td> <td> 0.020</td> <td>   -0.293</td> <td>   -0.025</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>VALUE</th>            <td>    0.1032</td> <td>    0.072</td> <td>    1.443</td> <td> 0.149</td> <td>   -0.037</td> <td>    0.243</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>YOJ</th>              <td>   -0.0632</td> <td>    0.041</td> <td>   -1.529</td> <td> 0.126</td> <td>   -0.144</td> <td>    0.018</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>CLAGE</th>            <td>   -0.4603</td> <td>    0.044</td> <td>  -10.418</td> <td> 0.000</td> <td>   -0.547</td> <td>   -0.374</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>NINQ</th>             <td>    0.2654</td> <td>    0.034</td> <td>    7.783</td> <td> 0.000</td> <td>    0.199</td> <td>    0.332</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>CLNO</th>             <td>   -0.1239</td> <td>    0.042</td> <td>   -2.935</td> <td> 0.003</td> <td>   -0.207</td> <td>   -0.041</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>DEBTINC</th>          <td>    0.4553</td> <td>    0.044</td> <td>   10.453</td> <td> 0.000</td> <td>    0.370</td> <td>    0.541</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>DEROGzero</th>        <td>   -1.1319</td> <td>    0.097</td> <td>  -11.699</td> <td> 0.000</td> <td>   -1.322</td> <td>   -0.942</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>REASON_HomeImp</th>   <td>    0.2636</td> <td>    0.085</td> <td>    3.110</td> <td> 0.002</td> <td>    0.097</td> <td>    0.430</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>REASON_IsMissing</th> <td>    0.3800</td> <td>    0.200</td> <td>    1.899</td> <td> 0.058</td> <td>   -0.012</td> <td>    0.772</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>JOB_Office</th>       <td>   -0.6031</td> <td>    0.148</td> <td>   -4.080</td> <td> 0.000</td> <td>   -0.893</td> <td>   -0.313</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>JOB_Other</th>        <td>    0.0227</td> <td>    0.114</td> <td>    0.198</td> <td> 0.843</td> <td>   -0.202</td> <td>    0.247</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>JOB_ProfExe</th>      <td>    0.0615</td> <td>    0.132</td> <td>    0.466</td> <td> 0.641</td> <td>   -0.197</td> <td>    0.320</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>JOB_Sales</th>        <td>    0.9846</td> <td>    0.260</td> <td>    3.781</td> <td> 0.000</td> <td>    0.474</td> <td>    1.495</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>JOB_Self</th>         <td>    0.6105</td> <td>    0.214</td> <td>    2.856</td> <td> 0.004</td> <td>    0.191</td> <td>    1.029</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>DELINQcat_1</th>      <td>    1.1885</td> <td>    0.104</td> <td>   11.473</td> <td> 0.000</td> <td>    0.985</td> <td>    1.392</td>\n",
              "</tr>\n",
              "<tr>\n",
              "  <th>DELINQcat_1+</th>     <td>    2.1401</td> <td>    0.112</td> <td>   19.161</td> <td> 0.000</td> <td>    1.921</td> <td>    2.359</td>\n",
              "</tr>\n",
              "</table>"
            ],
            "text/plain": [
              "<class 'statsmodels.iolib.summary.Summary'>\n",
              "\"\"\"\n",
              "                           Logit Regression Results                           \n",
              "==============================================================================\n",
              "Dep. Variable:                      y   No. Observations:                 5960\n",
              "Model:                          Logit   Df Residuals:                     5941\n",
              "Method:                           MLE   Df Model:                           18\n",
              "Date:                Wed, 05 May 2021   Pseudo R-squ.:                  0.2096\n",
              "Time:                        23:18:01   Log-Likelihood:                -2354.1\n",
              "converged:                       True   LL-Null:                       -2978.2\n",
              "Covariance Type:            nonrobust   LLR p-value:                5.257e-254\n",
              "====================================================================================\n",
              "                       coef    std err          z      P>|z|      [0.025      0.975]\n",
              "------------------------------------------------------------------------------------\n",
              "const               -1.1373      0.134     -8.494      0.000      -1.400      -0.875\n",
              "LOAN                -0.1692      0.043     -3.922      0.000      -0.254      -0.085\n",
              "MORTDUE             -0.1588      0.068     -2.321      0.020      -0.293      -0.025\n",
              "VALUE                0.1032      0.072      1.443      0.149      -0.037       0.243\n",
              "YOJ                 -0.0632      0.041     -1.529      0.126      -0.144       0.018\n",
              "CLAGE               -0.4603      0.044    -10.418      0.000      -0.547      -0.374\n",
              "NINQ                 0.2654      0.034      7.783      0.000       0.199       0.332\n",
              "CLNO                -0.1239      0.042     -2.935      0.003      -0.207      -0.041\n",
              "DEBTINC              0.4553      0.044     10.453      0.000       0.370       0.541\n",
              "DEROGzero           -1.1319      0.097    -11.699      0.000      -1.322      -0.942\n",
              "REASON_HomeImp       0.2636      0.085      3.110      0.002       0.097       0.430\n",
              "REASON_IsMissing     0.3800      0.200      1.899      0.058      -0.012       0.772\n",
              "JOB_Office          -0.6031      0.148     -4.080      0.000      -0.893      -0.313\n",
              "JOB_Other            0.0227      0.114      0.198      0.843      -0.202       0.247\n",
              "JOB_ProfExe          0.0615      0.132      0.466      0.641      -0.197       0.320\n",
              "JOB_Sales            0.9846      0.260      3.781      0.000       0.474       1.495\n",
              "JOB_Self             0.6105      0.214      2.856      0.004       0.191       1.029\n",
              "DELINQcat_1          1.1885      0.104     11.473      0.000       0.985       1.392\n",
              "DELINQcat_1+         2.1401      0.112     19.161      0.000       1.921       2.359\n",
              "====================================================================================\n",
              "\"\"\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kV1SAbWTVf24"
      },
      "source": [
        "Spend a little time on inspecting the table. The pseudo $R^2$ statistic suggests that the model explains only a moderate amount of the variability of the target variable. However, we find from the *LLR test* that the model as a whole is highly significant. Further, most features come out as significant,  two dummy variables for the job categories *prof. executive* and *other* and the feature VALUE being an exception. The result for the VALUE feature is surely due to the high correlation of this feature with MORTDUE (see correlation heatmap previous notebook).    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7QbSZ8oVf25",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf924b82-7565-472c-9266-1bff587728ba"
      },
      "source": [
        "import numpy as np\n",
        "np.corrcoef(df.MORTDUE, df.VALUE)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.        , 0.83451824],\n",
              "       [0.83451824, 1.        ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7LP4_ZmzVf29"
      },
      "source": [
        "Reestimating the logit model after removing the feature MORTDUE would be a good exercise. After the modification, VALUE should come out as significant.\n",
        "\n",
        "We could easily continue our discussion of the regression table to draw more conclusions about our data. However, this is not the point the focal tutorial. Instead, let's look at another implementation of logistic regression. The famous `scikit-learn` library is the goto library for machine learning in Python. We will use it intensively throughout the course. It also supplies an implementation of logistic regression. Let's see how to use that implementation      "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5ij5VpjkVf2-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1da01752-3ebd-4d19-bd61-3fd2d71eef1b"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "sk_logit = LogisticRegression(penalty='none', fit_intercept=False)  # Recall that we already included a constant column in X. \n",
        "sk_logit.fit(X, y)                                                  # So we must set fit_intercept to False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=False,\n",
              "                   intercept_scaling=1, l1_ratio=None, max_iter=100,\n",
              "                   multi_class='auto', n_jobs=None, penalty='none',\n",
              "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
              "                   warm_start=False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lcCMcjQLVf3C"
      },
      "source": [
        "The sklearn implementation is geared toward predictive modeling. For example, there is no way to easily obtain fitting statistics or shed light on the significance of features. On the other hand, the class `LogisticRegression` supports many advanced features to maximize the predictive power of the logit model. The above output already hints at the many different parameters that you can configure. Have a look into the help if you'd like to learn more. We will cover important parameters like those associated with *regularization* in the next notebook. One easy to appreciate advantage of `sklearn` over `statsmodels` when it comes to logistic regression is scalability. The sklearn implementation is faster and can cope with larger data sets.\n",
        "\n",
        "Given the differences between our two logit models, the only way to compare them (for now) is by inspecting the estimated model coefficients.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPyDAs0GVf3D",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 618
        },
        "outputId": "65f309db-71d1-425c-c8d4-eb6013175c3b"
      },
      "source": [
        "# Create a dataframe for the comparison\n",
        "# Note that we also need some conversions to ensure that the two coefficient arrays are compatible\n",
        "df_comparison = pd.DataFrame({\"statsmodels\" :logit_model.params.to_numpy(), \"sklearn\": sk_logit.coef_[0]})\n",
        "df_comparison"
      ],
      "execution_count": null,
      "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>statsmodels</th>\n",
              "      <th>sklearn</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>-1.137294</td>\n",
              "      <td>-1.137032</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-0.169232</td>\n",
              "      <td>-0.169243</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-0.158771</td>\n",
              "      <td>-0.158761</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.103176</td>\n",
              "      <td>0.103175</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-0.063161</td>\n",
              "      <td>-0.063177</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>-0.460291</td>\n",
              "      <td>-0.460302</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>0.265369</td>\n",
              "      <td>0.265376</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>-0.123915</td>\n",
              "      <td>-0.123935</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>0.455265</td>\n",
              "      <td>0.455277</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>-1.131884</td>\n",
              "      <td>-1.131949</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>10</th>\n",
              "      <td>0.263644</td>\n",
              "      <td>0.263535</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>11</th>\n",
              "      <td>0.380032</td>\n",
              "      <td>0.379806</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>12</th>\n",
              "      <td>-0.603123</td>\n",
              "      <td>-0.603243</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>13</th>\n",
              "      <td>0.022679</td>\n",
              "      <td>0.022508</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>14</th>\n",
              "      <td>0.061494</td>\n",
              "      <td>0.061328</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>15</th>\n",
              "      <td>0.984607</td>\n",
              "      <td>0.984903</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>16</th>\n",
              "      <td>0.610493</td>\n",
              "      <td>0.610371</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>17</th>\n",
              "      <td>1.188531</td>\n",
              "      <td>1.188530</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>18</th>\n",
              "      <td>2.140127</td>\n",
              "      <td>2.140086</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    statsmodels   sklearn\n",
              "0     -1.137294 -1.137032\n",
              "1     -0.169232 -0.169243\n",
              "2     -0.158771 -0.158761\n",
              "3      0.103176  0.103175\n",
              "4     -0.063161 -0.063177\n",
              "5     -0.460291 -0.460302\n",
              "6      0.265369  0.265376\n",
              "7     -0.123915 -0.123935\n",
              "8      0.455265  0.455277\n",
              "9     -1.131884 -1.131949\n",
              "10     0.263644  0.263535\n",
              "11     0.380032  0.379806\n",
              "12    -0.603123 -0.603243\n",
              "13     0.022679  0.022508\n",
              "14     0.061494  0.061328\n",
              "15     0.984607  0.984903\n",
              "16     0.610493  0.610371\n",
              "17     1.188531  1.188530\n",
              "18     2.140127  2.140086"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tybUfadmVf3H"
      },
      "source": [
        "**Conclusion:** the two implementations of the logit model deliver similar results. That is nice but maybe not too exciting. The main take-away is that, when it comes to logistic regression, ask yourself whether you want to use the model for an explanatory or predictive purpose. Use the implementation within `statsmodels` in the former and `sklearn` in the latter case. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-VlKNTmVf3H"
      },
      "source": [
        "# Decision Trees\n",
        "\n",
        "Decision trees are useful and powerful algorithms for classifying and regressing data. It works on recursive partitioning which will be shown algorithmically in this notebook. Though most of the the time, Sci-Kit Learn can be used to implement this machine learning method simply, it is useful to take a look at the inner workings of these algorithms. The following parts will first introduce a decision tree from scratch, before demonstrating its coverage in `sklearn`. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YjOnBPEXfHK0"
      },
      "source": [
        "## Decision Tree From Scratch Using HMEQ Data\n",
        "\n",
        "Firstly, we will go through a decision tree made from scratch. The following code is based on the material originally created by Sebastian Mantey for the Iris Dataset whose GitHub is here: https://github.com/SebastianMantey/Decision-Tree-from-Scratch. You can also search his video on YouTube. The code has been adapted to this course's format and fit to HMEQ Dataset.\n",
        "\n",
        "Just in case you made changes to the data by running the above code, we first reload the data to a fixed and clear-defined starting point for our tree classifier. Recall that we defined the variable `data_url` above."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        },
        "id": "I2zyH3v5fHK0",
        "outputId": "82fbd8c7-0545-4e7c-b7da-e0bb154bfc77"
      },
      "source": [
        "df = df_prep\n",
        "df.head() #inspect data to make sure it looks correct"
      ],
      "execution_count": null,
      "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>BAD</th>\n",
              "      <th>LOAN</th>\n",
              "      <th>MORTDUE</th>\n",
              "      <th>VALUE</th>\n",
              "      <th>YOJ</th>\n",
              "      <th>CLAGE</th>\n",
              "      <th>NINQ</th>\n",
              "      <th>CLNO</th>\n",
              "      <th>DEBTINC</th>\n",
              "      <th>DEROGzero</th>\n",
              "      <th>REASON_HomeImp</th>\n",
              "      <th>REASON_IsMissing</th>\n",
              "      <th>JOB_Office</th>\n",
              "      <th>JOB_Other</th>\n",
              "      <th>JOB_ProfExe</th>\n",
              "      <th>JOB_Sales</th>\n",
              "      <th>JOB_Self</th>\n",
              "      <th>DELINQcat_1</th>\n",
              "      <th>DELINQcat_1+</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.653277</td>\n",
              "      <td>-1.178335</td>\n",
              "      <td>-1.214631</td>\n",
              "      <td>0.240519</td>\n",
              "      <td>-1.048118</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-1.235873</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.634229</td>\n",
              "      <td>-0.057653</td>\n",
              "      <td>-0.634500</td>\n",
              "      <td>-0.241941</td>\n",
              "      <td>-0.708023</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.730854</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.615181</td>\n",
              "      <td>-1.491770</td>\n",
              "      <td>-1.655531</td>\n",
              "      <td>-0.655479</td>\n",
              "      <td>-0.365865</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-1.134869</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>True</td>\n",
              "      <td>-1.615181</td>\n",
              "      <td>-0.185310</td>\n",
              "      <td>-0.223017</td>\n",
              "      <td>-0.241941</td>\n",
              "      <td>-0.068694</td>\n",
              "      <td>-0.096401</td>\n",
              "      <td>-0.124831</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>False</td>\n",
              "      <td>-1.596133</td>\n",
              "      <td>0.645978</td>\n",
              "      <td>0.226563</td>\n",
              "      <td>-0.793325</td>\n",
              "      <td>-1.060913</td>\n",
              "      <td>-0.746347</td>\n",
              "      <td>-0.730854</td>\n",
              "      <td>0.136862</td>\n",
              "      <td>True</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     BAD      LOAN   MORTDUE  ...  JOB_Self  DELINQcat_1  DELINQcat_1+\n",
              "0   True -1.653277 -1.178335  ...         0            0             0\n",
              "1   True -1.634229 -0.057653  ...         0            0             1\n",
              "2   True -1.615181 -1.491770  ...         0            0             0\n",
              "3   True -1.615181 -0.185310  ...         0            0             0\n",
              "4  False -1.596133  0.645978  ...         0            0             0\n",
              "\n",
              "[5 rows x 19 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xQwXkg0SfHK1"
      },
      "source": [
        "X = df.drop(['BAD'], axis=1) #code the variables in the most standard way for your usage\n",
        "y = df[['BAD']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y7tOKwVtfHK1",
        "outputId": "d30b1616-c1e9-4a50-be9f-ec66b4c25439"
      },
      "source": [
        "print(type(X), type(y), X.shape, y.shape) # double check that types and dimensions are correct before proceeding"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'> <class 'pandas.core.frame.DataFrame'> (5960, 18) (5960, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1p-_lFYzfHK1"
      },
      "source": [
        "### Helper Functions for the Tree\n",
        "\n",
        "Decision trees work by recursively partitioning data which means:\n",
        "\n",
        "Many potential ways to split the data are calculated (eg. we are going to go through all unique values of each column and finding the midpoint between sequential values). For each potential split, we evaluate whether the target variable has more homogeneity in each leaf. This is done by calculating 'impurity' of the parent node and comparing it with the sum of the impurity of the child nodes. There are three major impurity functions: entropy, gini and misclassification. We will be using entropy in our example. The split which yields the lowest impurity is chosen and the process is repeated for the new nodes (this is recursion). \n",
        "\n",
        "The method of choosing the split which yields the lowest impurity is called the greedy search method. The following functions will help the decision tree implement greedy search tactics on the data. The algorithm stops either when purity in each node is reached or when it has reached a maximum depth (max amount of recursions we allow) specified in our function.\n",
        "\n",
        "Many functions for the tree are not found in Python packages and it is cleaner to write them out first then put them together in our main algorithm. Each function below does a specific action which will be used in our final tree function at the end."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LhGSx_3efHK1"
      },
      "source": [
        "def check_purity(y):\n",
        "    \n",
        "    'checks if a leaf node is perfectly pure, in other words, if the leaf node contains only one class'\n",
        "    \n",
        "    unique_classes = np.unique(y) #count number of classes in section of data\n",
        "\n",
        "    if len(unique_classes) == 1: #check if the node is pure\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lg6zDh56fHK1"
      },
      "source": [
        "def classify_data(y):\n",
        "    \n",
        "    'classifies data according to the majority class of each leaf'\n",
        "    \n",
        "    unique_classes, counts_unique_classes = np.unique(y, return_counts=True)\n",
        "    #returns classes and no. of obs per class\n",
        "\n",
        "    index = counts_unique_classes.argmax() #index of class with most obs\n",
        "    classification = unique_classes[index] #class chosen for classification which is class with most obs\n",
        "    \n",
        "    prob = len(y[y == 1]) / len(y) #returns proportion of class 1 in the leaf (prob of class 1)\n",
        "\n",
        "    return [classification, prob]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zNHzxN06fHK1"
      },
      "source": [
        "def get_potential_splits(X):\n",
        "    \n",
        "    'first, takes every unique value of every feature in the feature space, then finds the midpoint between each value'\n",
        "    \n",
        "    potential_splits = {}\n",
        "    _, n_columns = X.shape #don't need rows, we choose the column to split on\n",
        "    # only need second value of .shape which is columns\n",
        "    \n",
        "    for column_index in range(n_columns):\n",
        "        potential_splits[column_index] = [] \n",
        "        values = X[:, column_index] \n",
        "        unique_values = np.unique(values) #get all unique values in each column\n",
        "\n",
        "        for index in range(len(unique_values)): #all unique feature values\n",
        "            if index != 0: #skip first value, we need the difference between next values\n",
        "                current_value = unique_values[index]\n",
        "                previous_value = unique_values[index - 1] #find a value and the next smallest value\n",
        "                potential_split = (current_value + previous_value) / 2 #find difference between the two as a potential split\n",
        "                \n",
        "                #consider all values which lie between two values as a potential split\n",
        "                \n",
        "                potential_splits[column_index].append(potential_split)\n",
        "    \n",
        "    return potential_splits"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sgtBqNb0fHK1"
      },
      "source": [
        "def split_data(X, y, split_column, split_value):\n",
        "    \n",
        "    'splits data based on specific value, will yield both a split for the features X and target y'\n",
        "    \n",
        "    split_column_values = X[:, split_column]\n",
        "\n",
        "    X_below = X[split_column_values <= split_value] #partitions data according to split values from previous functions\n",
        "    X_above = X[split_column_values >  split_value]\n",
        "    \n",
        "    y_below = y[split_column_values <= split_value]\n",
        "    y_above = y[split_column_values >  split_value]\n",
        "    \n",
        "    return X_below, X_above, y_below, y_above"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CpXCl5jffHK1"
      },
      "source": [
        "def calculate_entropy(y):\n",
        "    \n",
        "    'calculates entropy for each partition of data'\n",
        "    \n",
        "    _, counts = np.unique(y, return_counts=True) #we only need the counts of each class, _ is a placeholder\n",
        "\n",
        "    probabilities = counts / counts.sum() #probability of each class\n",
        "    entropy = sum(probabilities * -np.log2(probabilities)) #could replace with Gini impurity or misclassification\n",
        "     \n",
        "    return entropy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oQAF-VaAfHK1"
      },
      "source": [
        "def calculate_overall_entropy(y_below, y_above): \n",
        "    \n",
        "    'calculates the total entropy after each split'\n",
        "       \n",
        "    n = len(y_below) + len(y_above)\n",
        "    p_data_below = len(y_below) / n\n",
        "    p_data_above = len(y_above) / n\n",
        "\n",
        "    overall_entropy =  (p_data_below * calculate_entropy(y_below)\n",
        "                      + p_data_above * calculate_entropy(y_above))\n",
        "    \n",
        "    return overall_entropy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NLItkeXGfHK2"
      },
      "source": [
        "def determine_best_split(X, y, potential_splits):\n",
        "    \n",
        "    'selects which split lowered entropy the most'\n",
        "    \n",
        "    overall_entropy = 9999 #set arbitrarily high, the function will loop over and replace this with lower impurity values\n",
        "    for column_index in potential_splits:\n",
        "        for value in potential_splits[column_index]:\n",
        "            X_below, X_above, y_below, y_above = split_data(X, y, split_column=column_index, split_value=value)\n",
        "            current_overall_entropy = calculate_overall_entropy(y_below, y_above)\n",
        "            \n",
        "            #goes through each potential split and only updates if it lowers entropy\n",
        "\n",
        "            if current_overall_entropy <= overall_entropy: \n",
        "                overall_entropy = current_overall_entropy #updates only if lower entropy split found, in the ned this is greedy search\n",
        "                best_split_column = column_index\n",
        "                best_split_value = value\n",
        "    \n",
        "    return best_split_column, best_split_value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j_QbUdkdfHK2"
      },
      "source": [
        "### The Main Algorithm\n",
        "\n",
        "The tree will now implement the helper functions and display the decision which yielded the best split if printed. Since the growing the tree can take a little bit of time, the argument `verbose` also exists which gives you status updates on the algorithm's progress. This is common for quite a few functions in the programming world."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buDByirD5kbJ"
      },
      "source": [
        "def decision_tree_algorithm(X, y, counter=0, min_samples=2, max_depth=5, verbose=False): \n",
        "    \n",
        "    # data preparation\n",
        "    if counter == 0:  # counter tells us how deep the tree is, this is before the tree is initiated\n",
        "        global COLUMN_HEADERS\n",
        "        COLUMN_HEADERS = X.columns\n",
        "        X = X.values  # change all to NumPy array for faster calculations\n",
        "        y = y.values\n",
        "        if verbose:\n",
        "          print(\"Data preparation complete, tree initiated\")\n",
        "          print(\"Creating first branch until first leaf, branches will then be calculated sequentially\")\n",
        "    else:\n",
        "        data = X  # if we have started the tree, X should already be a NumPy array from the code above \n",
        "    # base cases\n",
        "    if (check_purity(y)) or (len(X) < min_samples) or (counter == max_depth):\n",
        "        if verbose:\n",
        "          if (check_purity(y)):\n",
        "              print(\"Classes pure, new leaf node created\")\n",
        "          elif (len(X) < min_samples):\n",
        "              print(\"Min samples reached, new leaf node created\")\n",
        "          else:\n",
        "              print(\"Max depth reached, new leaf node created\")\n",
        "        classification, prob = classify_data(y)\n",
        "        return classification, prob\n",
        "    \n",
        "    # recursive part\n",
        "    else:    \n",
        "\n",
        "        # helper functions \n",
        "        if verbose:\n",
        "            print(\"Calculating splits at depth of\", counter)\n",
        "        potential_splits = get_potential_splits(X)  # check for all possible splits\n",
        "\n",
        "        if bool([feature_splits for feature_splits in potential_splits.values() if feature_splits != []]): # Checks that potential_splits is not just a blank dictionary (occurs when random feature subspace has no variation in observations)        \n",
        "            best_split_column, best_split_value = determine_best_split(X, y, potential_splits)  # select best split based on entropy\n",
        "            X_below, X_above, y_below, y_above = split_data(X, y, best_split_column, best_split_value)  # execute best split\n",
        "         \n",
        "            # Code to explain decisions made by tree to users\n",
        "            feature_name = COLUMN_HEADERS[best_split_column]\n",
        "            question = \"{} <= {}\".format(feature_name, best_split_value)  # initiate explanation of split\n",
        "            sub_tree = {question: []}\n",
        "        \n",
        "            # Pull answers from tree\n",
        "            if verbose:\n",
        "                print(\"Processing first split at depth\", counter)\n",
        "            yes_answer = decision_tree_algorithm(X_below, y_below, counter + 1, min_samples, max_depth, verbose)\n",
        "            if verbose:\n",
        "                print(\"Processing second split at depth\", counter)\n",
        "            no_answer = decision_tree_algorithm(X_above, y_above, counter + 1, min_samples, max_depth, verbose)\n",
        "        \n",
        "            # Ensure explanation actually shows useful information\n",
        "            if yes_answer == no_answer:  # if decisions are the same, only display one\n",
        "                sub_tree = yes_answer\n",
        "            else:\n",
        "                sub_tree[question].append(yes_answer)\n",
        "                sub_tree[question].append(no_answer)\n",
        "\n",
        "            if verbose:\n",
        "             if (counter == 0):\n",
        "                print(\"Tree Complete\")\n",
        "\n",
        "        else: # if potential_splits is empty due to lack of feature variation, just classify the data at this point\n",
        "            classification = classify_data(y)\n",
        "            return classification\n",
        "        \n",
        "        return sub_tree"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yt9v0ldZfHK2"
      },
      "source": [
        "### Grow First Tree\n",
        "\n",
        "Test the tree and display the decisions with a shallow depth."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CxqcpI_3fHK2",
        "outputId": "adc652fd-2f6d-4a2f-d1fa-c3f402f73a71"
      },
      "source": [
        "tree = decision_tree_algorithm(X, y, max_depth=2, verbose=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data preparation complete, tree initiated\n",
            "Creating first branch until first leaf, branches will then be calculated sequentially\n",
            "Calculating splits at depth of 0\n",
            "Processing first split at depth 0\n",
            "Calculating splits at depth of 1\n",
            "Processing first split at depth 1\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 1\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 0\n",
            "Calculating splits at depth of 1\n",
            "Processing first split at depth 1\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 1\n",
            "Max depth reached, new leaf node created\n",
            "Tree Complete\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pz8boTvjfHK2"
      },
      "source": [
        "#### Structure of the First Tree"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u-eOLiADfHK2",
        "scrolled": true,
        "outputId": "9ab8b155-e313-4cc8-a13a-ecff9800fe68"
      },
      "source": [
        "from pprint import pprint  # library for prettier print output\n",
        "\n",
        "pprint(tree)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'DEBTINC <= 0.13240349139938384': [{'DELINQcat_1+ <= 0.5': [(False,\n",
            "                                                              0.04424379232505643),\n",
            "                                                             (False,\n",
            "                                                              0.2777777777777778)]},\n",
            "                                    {'DEBTINC <= 0.13687545463264447': [(True,\n",
            "                                                                         0.6182246661429693),\n",
            "                                                                        (False,\n",
            "                                                                         0.11466325660699062)]}]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AK0KBq9XfHK2",
        "outputId": "ad9b37f7-5f6f-45a6-e895-045d603fe119"
      },
      "source": [
        "tree.values()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values([[{'DELINQcat_1+ <= 0.5': [(False, 0.04424379232505643), (False, 0.2777777777777778)]}, {'DEBTINC <= 0.13687545463264447': [(True, 0.6182246661429693), (False, 0.11466325660699062)]}]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PkaCufj0fHK2"
      },
      "source": [
        "The first node in the tree asks the question:\n",
        "\n",
        "DEBTINC <= 0.13240349139938384\n",
        "\n",
        "If this is true, the tree will predict BAD as false.\n",
        "\n",
        "If this is false, the tree will ask a second question:\n",
        "\n",
        "DEBTINC <= 0.13687545463264447\n",
        "\n",
        "If true, the tree will predict BAD is true. If false, the tree will predict BAD is false."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MC_T56DrfHK2"
      },
      "source": [
        "#### Classification Example from First Tree\n",
        "\n",
        "Let's take an example and see how the tree classifies it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6bVttPZlfHK2",
        "outputId": "335396fb-8c13-47b2-aa4b-7418ce656c3a"
      },
      "source": [
        "example = df.iloc[2] #take a random observation\n",
        "example"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "BAD                      True\n",
              "LOAN                 -1.61518\n",
              "MORTDUE              -1.49177\n",
              "VALUE                -1.65553\n",
              "YOJ                 -0.655479\n",
              "CLAGE               -0.365865\n",
              "NINQ               -0.0964013\n",
              "CLNO                 -1.13487\n",
              "DEBTINC              0.136862\n",
              "DEROGzero                True\n",
              "REASON_HomeImp              1\n",
              "REASON_IsMissing            0\n",
              "JOB_Office                  0\n",
              "JOB_Other                   1\n",
              "JOB_ProfExe                 0\n",
              "JOB_Sales                   0\n",
              "JOB_Self                    0\n",
              "DELINQcat_1                 0\n",
              "DELINQcat_1+                0\n",
              "Name: 2, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NNHQD5T9ZvUP"
      },
      "source": [
        "To put this example down our tree, we implement a function `classify_example()`. Eventually, we would like our tree to facilitate prediction in a similar way as `sklearn` models. Therefore, we also implement two *wrapper* functions `predict()` and `predict_proba()`; as we did before for our custom logit model. These functions kind of 'wrap up' the function `classify_example()` - hence the name wrapper function - and call it for every instance in a data set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pj2LL01HfHK2"
      },
      "source": [
        "def classify_example(example, tree):\n",
        "    question = list(tree.keys())[0] #checks what is the next data split\n",
        "    feature_name, comparison_operator, value = question.split() #splits question into elements\n",
        "\n",
        "    # ask question\n",
        "    if example[feature_name] <= float(value): # checks key element for split\n",
        "        answer = tree[question][0] # selects yes answer\n",
        "    else:\n",
        "        answer = tree[question][1] # selects no answer\n",
        "\n",
        "    # base case\n",
        "    if not isinstance(answer, dict): # if answer is not a dictionary, we have reached a decision\n",
        "        return answer # display prediction\n",
        "    \n",
        "    # recursive part\n",
        "    else:\n",
        "        residual_tree = answer # continue if another dictionary is reached\n",
        "        return classify_example(example, residual_tree)\n",
        "\n",
        "# function for predicting class of observation\n",
        "def predict(tree, data):\n",
        "  pred = data.apply(classify_example, axis=1, args=(tree,))\n",
        "  return [int(row[0]) for row in pred]\n",
        "\n",
        "# function for predicting probability of observation being class 1 \n",
        "def predict_prob(tree, data):\n",
        "  pred = data.apply(classify_example, axis=1, args=(tree,))\n",
        "  return [row[1] for row in pred]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CkbFQpN4ZvUP"
      },
      "source": [
        "Ok, finally, here is the classification result for the above instance:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yKAAKTB6fHK2",
        "outputId": "fdff33c1-c59d-4fc7-b676-6558c11023c3"
      },
      "source": [
        "classify_example(example, tree)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, 0.6182246661429693)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oZlyn-UbfHK2",
        "outputId": "1cdd9a04-58c9-4925-cfff-8de923d9eb73"
      },
      "source": [
        "y.iloc[2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "BAD    True\n",
              "Name: 2, dtype: bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qs0EdAtUfHK2"
      },
      "source": [
        "The classification for this one instance is correct. It will be more interesting though to examine how well the tree classifiers a set of - or all - instances in our data. This is where our `predict()` functions come into play. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M2LhiN3jZvUP"
      },
      "source": [
        "#### Predictions and Accuracy from First Tree"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lwkFg2YzfHK2",
        "outputId": "daacb4a0-7c89-489a-b0d0-7cf8e94c9177"
      },
      "source": [
        "predictions = predict(tree, X)  # obtain discrete class predictions (i.e., majority class in the respective leaf nodes)\n",
        "\n",
        "predictions[:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 1, 1, 1, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-29Sz93zYu_R",
        "outputId": "33922d3d-833c-4615-b600-77acb366a8b9"
      },
      "source": [
        "predictions_prob = predict_prob(tree, X) #probability of being class 1\n",
        "\n",
        "predictions_prob[:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.6182246661429693,\n",
              " 0.6182246661429693,\n",
              " 0.6182246661429693,\n",
              " 0.6182246661429693,\n",
              " 0.6182246661429693]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ITH87JpTfHK2",
        "outputId": "b2b4c8a0-fe9c-484e-fc4d-79925dd97092"
      },
      "source": [
        "error = np.mean(np.vstack(predictions) == np.array(y))\n",
        "\n",
        "error"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.851006711409396"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sLnc0niWfHK2"
      },
      "source": [
        "The tree is able to classify a good proportion of the test set well even with only a depth of 2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q9BColNWfHK2"
      },
      "source": [
        "### Higher Depth in Tree\n",
        "\n",
        "Test the tree and display the decisions with a higher depth to see if accuracy changed. Be warned, the computations might take a few minutes to complete. After growing the tree, we will proceed as before with calculating predictions and examining their accuracy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DGO-xjnyfHK2",
        "outputId": "53cf7e95-95f7-437f-c8af-3d19199ca354"
      },
      "source": [
        "tree_deep = decision_tree_algorithm(X, y, max_depth=5, verbose=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data preparation complete, tree initiated\n",
            "Creating first branch until first leaf, branches will then be calculated sequentially\n",
            "Calculating splits at depth of 0\n",
            "Processing first split at depth 0\n",
            "Calculating splits at depth of 1\n",
            "Processing first split at depth 1\n",
            "Calculating splits at depth of 2\n",
            "Processing first split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 1\n",
            "Calculating splits at depth of 2\n",
            "Processing first split at depth 2\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 0\n",
            "Calculating splits at depth of 1\n",
            "Processing first split at depth 1\n",
            "Calculating splits at depth of 2\n",
            "Processing first split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 1\n",
            "Calculating splits at depth of 2\n",
            "Processing first split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Max depth reached, new leaf node created\n",
            "Processing second split at depth 2\n",
            "Calculating splits at depth of 3\n",
            "Processing first split at depth 3\n",
            "Calculating splits at depth of 4\n",
            "Processing first split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 4\n",
            "Classes pure, new leaf node created\n",
            "Processing second split at depth 3\n",
            "Classes pure, new leaf node created\n",
            "Tree Complete\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BolXOVjR-huJ",
        "outputId": "d6265ce7-1533-4138-ceda-614118ae52ac"
      },
      "source": [
        "pprint(tree_deep)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'DEBTINC <= 0.13240349139938384': [{'DELINQcat_1+ <= 0.5': [{'YOJ <= -0.4487102147295737': [{'MORTDUE <= -0.8870514615355474': [{'LOAN <= -0.515166499603934': [(False,\n",
            "                                                                                                                                                                  0.46875),\n",
            "                                                                                                                                                                 (False,\n",
            "                                                                                                                                                                  0.07407407407407407)]},\n",
            "                                                                                                                                 {'CLAGE <= -1.556644606385396': [(True,\n",
            "                                                                                                                                                                   1.0),\n",
            "                                                                                                                                                                  (False,\n",
            "                                                                                                                                                                   0.05263157894736842)]}]},\n",
            "                                                                                             {'CLNO <= -1.8923979785547935': [{'NINQ <= 1.8534346295937214': [(True,\n",
            "                                                                                                                                                               1.0),\n",
            "                                                                                                                                                              (False,\n",
            "                                                                                                                                                               0.0)]},\n",
            "                                                                                                                              {'VALUE <= 0.9111073465898447': [(False,\n",
            "                                                                                                                                                                0.02585487906588824),\n",
            "                                                                                                                                                               (False,\n",
            "                                                                                                                                                                0.0)]}]}]},\n",
            "                                                             {'DEBTINC <= -2.181832076478061': [(True,\n",
            "                                                                                                 1.0),\n",
            "                                                                                                {'CLNO <= 0.3296859408844675': [{'MORTDUE <= -0.13913124301235122': [(False,\n",
            "                                                                                                                                                                      0.23809523809523808),\n",
            "                                                                                                                                                                     (True,\n",
            "                                                                                                                                                                      0.8181818181818182)]},\n",
            "                                                                                                                                {'NINQ <= 1.5284619774291361': [(False,\n",
            "                                                                                                                                                                 0.03389830508474576),\n",
            "                                                                                                                                                                (True,\n",
            "                                                                                                                                                                 1.0)]}]}]}]},\n",
            "                                    {'DEBTINC <= 0.13687545463264447': [{'DELINQcat_1+ <= 0.5': [{'CLAGE <= -0.011315615503282438': [{'DEROGzero <= 0.5': [(True,\n",
            "                                                                                                                                                            0.8467153284671532),\n",
            "                                                                                                                                                           (True,\n",
            "                                                                                                                                                            0.61003861003861)]},\n",
            "                                                                                                                                     {'DELINQcat_1 <= 0.5': [(False,\n",
            "                                                                                                                                                              0.29328621908127206),\n",
            "                                                                                                                                                             (True,\n",
            "                                                                                                                                                              0.6296296296296297)]}]},\n",
            "                                                                                                 {'NINQ <= 1.5284619774291361': [{'CLAGE <= 2.632873290470523': [(True,\n",
            "                                                                                                                                                                  0.8564814814814815),\n",
            "                                                                                                                                                                 (False,\n",
            "                                                                                                                                                                  0.0)]},\n",
            "                                                                                                                                 (True,\n",
            "                                                                                                                                  1.0)]}]},\n",
            "                                                                        {'DEBTINC <= 1.7107501780417875': [{'CLAGE <= 0.2870992189022679': [{'DEROGzero <= 0.5': [(False,\n",
            "                                                                                                                                                                   0.319672131147541),\n",
            "                                                                                                                                                                  (False,\n",
            "                                                                                                                                                                   0.0959119496855346)]},\n",
            "                                                                                                                                            {'DELINQcat_1+ <= 0.5': [(False,\n",
            "                                                                                                                                                                      0.019161676646706587),\n",
            "                                                                                                                                                                     (False,\n",
            "                                                                                                                                                                      0.37142857142857144)]}]},\n",
            "                                                                                                           {'DEBTINC <= 1.7871844346137968': [{'REASON_HomeImp <= 0.5': [(True,\n",
            "                                                                                                                                                                          1.0),\n",
            "                                                                                                                                                                         (False,\n",
            "                                                                                                                                                                          0.0)]},\n",
            "                                                                                                                                              (True,\n",
            "                                                                                                                                               1.0)]}]}]}]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kTuXwY5DfHK3",
        "outputId": "70cb0978-9756-4166-b319-89381d4890c4"
      },
      "source": [
        "predictions_deep = predict(tree_deep, X)\n",
        "\n",
        "predictions_deep[:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 1, 1, 1, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 131
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cWaQxYrsZkuY",
        "outputId": "09fa98b4-335a-4e01-b3bc-14272b2b067b"
      },
      "source": [
        "predictions_prob_deep = predict_prob(tree_deep, X)\n",
        "\n",
        "predictions_prob_deep[:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.61003861003861,\n",
              " 0.8564814814814815,\n",
              " 0.61003861003861,\n",
              " 0.61003861003861,\n",
              " 0.61003861003861]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pP4SrqQLfHK3",
        "outputId": "48aa3e2e-2ac8-4deb-d588-467ee3303e08"
      },
      "source": [
        "error_deep = np.mean(np.vstack(predictions_deep) == np.array(y))\n",
        "\n",
        "error_deep"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8897651006711409"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kN-4UJIJfHK3"
      },
      "source": [
        "The performance of the tree is even better with this depth. However, as we continue to increase depth, there will come a point where the accuracy decreases as the tree internalizes noise from the data. This is called overfitting and weakens the tree's ability to classify unseen observations. Thus, the tree can be deepened only until the test set accuracy begins decreasing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24iH_u3ANDol"
      },
      "source": [
        "## Decision Trees with Sci-Kit Learn\n",
        "\n",
        "As mentioned, the package Ski-Kit Learn has prebuilt functions which avoid coding most algorithms by scratch. Now armed with the knowledge of the inner workings of the decision tree, it should be easier to understand what this algorithm is trying to achieve."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y4Fd0cChNDol"
      },
      "source": [
        "from sklearn import tree\n",
        "\n",
        "clf = tree.DecisionTreeClassifier(criterion=\"entropy\", min_samples_split=2, max_depth=2) #keep tree at a low depth\n",
        "\n",
        "dt_shallow = clf.fit(X, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v_KPNLD6NDon"
      },
      "source": [
        "pred_dt_shallow = dt_shallow.predict(X)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k6CTpH7yNDoq",
        "outputId": "f23775b9-e7c2-4273-ebbf-7fdbcab1e6a3"
      },
      "source": [
        "pred_dt_shallow[0:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True,  True])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lJT5XZOsNDos",
        "outputId": "c21ca6e4-d2c2-4249-8ba1-b3912068a423"
      },
      "source": [
        "classify_correct_shallow = pred_dt_shallow == y.iloc[:,0]\n",
        "accuracy_shallow = classify_correct_shallow.mean()\n",
        "\n",
        "\n",
        "accuracy_shallow"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.851006711409396"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 137
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 382
        },
        "id": "L7n0bgMhNDow",
        "outputId": "35b56ebe-ea58-4a44-9998-70caf98608c8"
      },
      "source": [
        "tree.plot_tree(dt_shallow, fontsize=8)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Text(167.4, 181.2, 'X[7] <= 0.132\\nentropy = 0.721\\nsamples = 5960\\nvalue = [4771, 1189]'),\n",
              " Text(83.7, 108.72, 'X[17] <= 0.5\\nentropy = 0.315\\nsamples = 2341\\nvalue = [2208, 133]'),\n",
              " Text(41.85, 36.23999999999998, 'entropy = 0.261\\nsamples = 2215\\nvalue = [2117, 98]'),\n",
              " Text(125.55000000000001, 36.23999999999998, 'entropy = 0.852\\nsamples = 126\\nvalue = [91, 35]'),\n",
              " Text(251.10000000000002, 108.72, 'X[7] <= 0.137\\nentropy = 0.871\\nsamples = 3619\\nvalue = [2563, 1056]'),\n",
              " Text(209.25, 36.23999999999998, 'entropy = 0.959\\nsamples = 1273\\nvalue = [486, 787]'),\n",
              " Text(292.95, 36.23999999999998, 'entropy = 0.514\\nsamples = 2346\\nvalue = [2077, 269]')]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 138
        },
        {
          "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": "Q8I98tRbNDoz"
      },
      "source": [
        "### SK Learn Tree with No Limit on Depth\n",
        "\n",
        "If we remove the maximum depth parameter, the algorithm will go as far as it can until all nodes are pure."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y4HfrTLyNDoz"
      },
      "source": [
        "clf = tree.DecisionTreeClassifier(criterion='entropy', min_samples_split=2)\n",
        "\n",
        "dt_deep = clf.fit(X, y)\n",
        "\n",
        "pred_dt_deep = dt_deep.predict(X)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Na0BNJFNDo1",
        "outputId": "1e63ada4-4ed0-41bd-d10b-9fb8a961da6f"
      },
      "source": [
        "pred_dt_deep[0:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True, False])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-rfG-hbNDo3",
        "outputId": "ef6dec9f-85bb-4026-af59-c2b827531413"
      },
      "source": [
        "classify_correct_deep = pred_dt_deep == y.iloc[:,0]\n",
        "accuracy_deep = classify_correct_deep.mean()\n",
        "\n",
        "accuracy_deep"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 141
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bs1jcqGTNDo5"
      },
      "source": [
        "While this seems great at first glance, what is the problem here? What does this mean for new data that we encounter whose idiosyncracies may be slightly different than the data we used to train the model?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63MGs5D4bYdu"
      },
      "source": [
        "# Conclusion\n",
        "\n",
        "There you have it! We have taken many strides to get to this point to complete your first regression and classification problems! There are many ways to refine the technique, we'll keep learning more in the next lessons and tutorials. Try some of these on your own and see if you can get some of your own models up and running.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7Dvvucmg4wI"
      },
      "source": [
        "## Overview Table\n",
        "\n",
        "NumPy code which was used here:\n",
        "\n",
        "\n",
        "| Goal | Possible Code |\n",
        "| --- | --- |\n",
        "| Generate n evenly spaced numbers between min and max | `np.linspace(min, max, num=n)` |\n",
        "| Generate n sized array drawn from specified random normal | `np.random.normal(loc=mean, scale=var, size=n)` |\n",
        "| Arrange array vertically | `np.vstack(array)` |\n",
        "| Concatenate arrays | `np.concatenate(array1, array2)` |\n",
        "| Create a matrix or array of 1s in the shape of 2 rows and 2 cols | `np.ones((2,2))` |\n",
        "| Dot product of two arrays | `np.dot(array1, array2)`|\n",
        "| If else with NumPy array | `np.where(condition, value_if_true, value_if_false)` |\n",
        "| If array element < 1:  multiply element by two, else: set element to 0 | `np.where(array<1, array*2, 0)` |\n",
        "| Create correlation matrix of two arrays or `pandas` Series | `np.corrcoef(array, array)` |\n",
        "\n",
        "`statsmodels.api` code for logistic regression:\n",
        "\n",
        "| Goal | Possible Code |\n",
        "| --- | --- |\n",
        "| Add constant to features | `add_constant(X, prepend=True, has_constant='raise')` |\n",
        "| Generate logistic regression | `sm.Logit(y.astype(int), X.astype(float), ) ` |\n",
        "| Fit logistic regression | `model_name.fit()` |\n",
        "| Get summary of regression | `fitted_model.summary()` |\n",
        "\n",
        "*Note that you must save the fitted model under a new name with `statsmodels.api`. It was overwritten in the same name in this tutorial.\n",
        "\n",
        "`sklearn` code implemented here:\n",
        "\n",
        "| Goal | Possible Code |\n",
        "| --- | --- |\n",
        "| Generate decision tree classifier | `tree.DecisionTreeClassifier()` |\n",
        "| Generate logistic regression | `LogisticRegression(penalty='none', fit_intercept=False) ` |\n",
        "| Fit model to X and y | `model_name.fit(X, y)`|\n",
        "| Predict based on X | `model_name.predict(X)` |"
      ]
    }
  ]
}