3-2 Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Homework_3_2.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mwNEDkhFtxwC"
      },
      "source": [
        "# <font style=\"font-size:40px\"><center><b>Machine Learning</b></center></font><font                        style=\"font-size:30px\"><center><b>Master in Computational Finance (MCF) </b></center></font> \n",
        "\n",
        "<center> \n",
        "\n",
        "# ![Screen Shot 2021-07-11 at 13.37.02 PM.png](data:image/png;base64,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)\n",
        "\n",
        "<center/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aihhzeTmt6TX"
      },
      "source": [
        "# <font color='tomato' style=\"font-size:40px\"><center><b>Homework 3</b></center></font></b></center></font> \n",
        "\n",
        "<center>\n",
        "<b>profesor: </b> Nikola Vasiljevic\n",
        "\n",
        "<b>students: </b> \n",
        "Nikola Krivacevic, Aleksandar Milinkovic\n",
        "</center>\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2 Horse Races of Classification Methods "
      ],
      "metadata": {
        "id": "gK1awqn_sa6p"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Based on your results and conclusions drawn from the logistic regression analysis, generate\n",
        "the key performance evaluation metrics of your choice for logistic regression, linear SVC,\n",
        "KNN, decision tree, and random forest algorithms. Report the results in a tabular format.\n",
        "Use the scaled features to run the analysis for all the models. For the optimal probability\n",
        "threshold, select the value that resulted in best performance of the logistic-regression-based\n",
        "classification in the section (c) of the first problem.\n",
        "\n",
        "*Remark:* You can consider either the scaled features with or without additional data pre-\n",
        "processing, depending on the conclusions drawn in the part (a) of the first problem."
      ],
      "metadata": {
        "id": "n5jDSjFuJYi4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing Libraries"
      ],
      "metadata": {
        "id": "5CZkVhuouzqQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import / install relevant Python packages\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "from sklearn.model_selection import (KFold, GridSearchCV, RandomizedSearchCV, cross_val_score)\n",
        "from sklearn import metrics\n",
        "from sklearn.metrics import (classification_report, confusion_matrix)\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.gridspec import GridSpec\n",
        "plt.style.use('ggplot')\n",
        "import seaborn as sns\n"
      ],
      "metadata": {
        "id": "os5YhSWVu4hD"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Helper functions"
      ],
      "metadata": {
        "id": "PPfz5StqH0qE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def classification_metrics(y_pred, y_true):\n",
        "\n",
        "  accuracy = metrics.accuracy_score(y_pred,y_true)\n",
        "  precision = metrics.recall_score(y_pred,y_true)\n",
        "  recall = metrics.precision_score(y_pred,y_true)\n",
        "  f1 = metrics.f1_score(y_pred,y_true)\n",
        "  return {\n",
        "      \"Accuraccy\": accuracy,\n",
        "      \"Precision\": precision,\n",
        "      \"Recall\": recall,\n",
        "      \"F1\": f1\n",
        "  }"
      ],
      "metadata": {
        "id": "WvQCN-T7H-WV"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Preparing data and loading results from the first problem (*Homework_3_1.ipynb*)"
      ],
      "metadata": {
        "id": "SN26L2YLvOx8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing Dataset - Credit Card Defaults in Taiwan in 2005 (data is already preprocessed and scaled in the first problem)"
      ],
      "metadata": {
        "id": "DCGlw_k2Lm5f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# UCI_Credit_Card (Engineered Features).csv should be uploaded\n",
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "Lx8ZoVMuvXXS",
        "outputId": "03fcaf94-5cf0-4250-84de-5947576ac55c"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-e12b89b5-e9f9-4bdc-a740-1f27ad28e36a\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-e12b89b5-e9f9-4bdc-a740-1f27ad28e36a\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving UCI_Credit_Card (Engineered Features).csv to UCI_Credit_Card (Engineered Features) (3).csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Splitting the data into training and test set"
      ],
      "metadata": {
        "id": "C4OV7zPGLt-Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = pd.read_csv('UCI_Credit_Card (Engineered Features).csv')\n",
        "data.drop(columns=data.columns[0], axis=1, inplace=True)\n",
        "data.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "pU0TEoSBL0Up",
        "outputId": "931daf0d-3ca2-4722-da18-4230081f5b98"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-44ca9878-7e5e-43b2-80b4-6171d7271656\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>PAY_0</th>\n",
              "      <th>BILL_AMT1</th>\n",
              "      <th>PAY_0 BILL_AMT1</th>\n",
              "      <th>PAY_3 BILL_AMT1</th>\n",
              "      <th>DEFAULT</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1.942687</td>\n",
              "      <td>-0.642501</td>\n",
              "      <td>-1.248179</td>\n",
              "      <td>0.607993</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-1.085297</td>\n",
              "      <td>-0.659219</td>\n",
              "      <td>0.715448</td>\n",
              "      <td>-0.019315</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-0.075969</td>\n",
              "      <td>-0.298560</td>\n",
              "      <td>0.022681</td>\n",
              "      <td>-0.008748</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>-0.075969</td>\n",
              "      <td>-0.057491</td>\n",
              "      <td>0.004368</td>\n",
              "      <td>-0.001685</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-1.085297</td>\n",
              "      <td>-0.578618</td>\n",
              "      <td>0.627972</td>\n",
              "      <td>0.547541</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-44ca9878-7e5e-43b2-80b4-6171d7271656')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-44ca9878-7e5e-43b2-80b4-6171d7271656 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-44ca9878-7e5e-43b2-80b4-6171d7271656');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "      PAY_0  BILL_AMT1  PAY_0 BILL_AMT1  PAY_3 BILL_AMT1  DEFAULT\n",
              "0  1.942687  -0.642501        -1.248179         0.607993        1\n",
              "1 -1.085297  -0.659219         0.715448        -0.019315        1\n",
              "2 -0.075969  -0.298560         0.022681        -0.008748        0\n",
              "3 -0.075969  -0.057491         0.004368        -0.001685        0\n",
              "4 -1.085297  -0.578618         0.627972         0.547541        0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Splitting the features and target variables\n",
        "X = data.drop('DEFAULT', axis='columns')\n",
        "y = data['DEFAULT']\n",
        "y.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "11_InxnEPy7t",
        "outputId": "ee301b54-0458-448c-fe42-2019def15d4a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    1\n",
              "1    1\n",
              "2    0\n",
              "3    0\n",
              "4    0\n",
              "Name: DEFAULT, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's now also split our dataset into the:\n",
        "- Training set (80% of the observations -> 24,000 observations)\n",
        "- Testing set (20% of the observations -> 6,000 observations)"
      ],
      "metadata": {
        "id": "tx-7za7xmo8h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_scaled_train, X_scaled_test, y_scaled_train, y_scaled_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "print(f'Features: train={len(X_scaled_train)} test={len(X_scaled_test)}')\n",
        "print(f'Target: train={len(y_scaled_train)} test={len(y_scaled_test)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UDNKb1e2OjF3",
        "outputId": "7d27fb5b-7f8f-4059-9ddb-2511063d735e"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Features: train=24000 test=6000\n",
            "Target: train=24000 test=6000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Optimal Probability Threshold\n",
        "\n",
        "Based on the calculations in the first problem, optimal probability threshold that will be used in this problem is ~ 0.217658"
      ],
      "metadata": {
        "id": "Xitb0ct5QiGz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "optimal_threshold = 0.217658"
      ],
      "metadata": {
        "id": "liXpu5fJRtcc"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comparison of different Classification Methods\n",
        "\n",
        "Let's compare the different Classification Methods. All results for logistic regression can be found in the first problem notebook."
      ],
      "metadata": {
        "id": "YQR6Ro0OKyZ6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1. Linear SVC"
      ],
      "metadata": {
        "id": "AMl96WFYLB1W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.svm import LinearSVC\n",
        "from sklearn.calibration import CalibratedClassifierCV\n",
        "\n",
        "# Define the cross-validation approach\n",
        "n_cv_lsvc = 5\n",
        "\n",
        "# Define the maximum number of iterations\n",
        "n_max_iter = 2000\n",
        "\n",
        "# Create an instance of the class LinearSVC\n",
        "lsvc_model = LinearSVC(max_iter=n_max_iter)\n",
        "\n",
        "# Define the search space for the hyperparameters\n",
        "search_space = dict()\n",
        "search_space['penalty'] = ['l1', 'l2']\n",
        "search_space['loss']    = ['hinge', 'squared_hinge']\n",
        "search_space['C']       = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]\n",
        "\n",
        "# Create an instance of the class GridSearchCV with desired characteristics\n",
        "lsvc_grid_search_cv_scaled = GridSearchCV(estimator=lsvc_model, \n",
        "                                          param_grid=search_space, \n",
        "                                          scoring='accuracy', \n",
        "                                          cv=n_cv_lsvc, \n",
        "                                          n_jobs=-1)\n",
        "\n",
        "# Run the search algorithm and summarize resuts \n",
        "lsvc_grid_search_cv_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "print(f'Best score: {lsvc_grid_search_cv_scaled.best_score_:.4f}')\n",
        "print('Best hyperparameters: %s' % lsvc_grid_search_cv_scaled.best_params_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KgRgRDmoSveM",
        "outputId": "1674a548-e1c4-412c-b17a-558d7cff9e70"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/model_selection/_validation.py:372: FitFailedWarning: \n",
            "80 fits failed out of a total of 160.\n",
            "The score on these train-test partitions for these parameters will be set to nan.\n",
            "If these failures are not expected, you can try to debug them by setting error_score='raise'.\n",
            "\n",
            "Below are more details about the failures:\n",
            "--------------------------------------------------------------------------------\n",
            "40 fits failed with the following error:\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/model_selection/_validation.py\", line 680, in _fit_and_score\n",
            "    estimator.fit(X_train, y_train, **fit_params)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_classes.py\", line 272, in fit\n",
            "    sample_weight=sample_weight,\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py\", line 1185, in _fit_liblinear\n",
            "    solver_type = _get_liblinear_solver_type(multi_class, penalty, loss, dual)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py\", line 1026, in _get_liblinear_solver_type\n",
            "    % (error_string, penalty, loss, dual)\n",
            "ValueError: Unsupported set of arguments: The combination of penalty='l1' and loss='hinge' is not supported, Parameters: penalty='l1', loss='hinge', dual=True\n",
            "\n",
            "--------------------------------------------------------------------------------\n",
            "40 fits failed with the following error:\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/model_selection/_validation.py\", line 680, in _fit_and_score\n",
            "    estimator.fit(X_train, y_train, **fit_params)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_classes.py\", line 272, in fit\n",
            "    sample_weight=sample_weight,\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py\", line 1185, in _fit_liblinear\n",
            "    solver_type = _get_liblinear_solver_type(multi_class, penalty, loss, dual)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py\", line 1026, in _get_liblinear_solver_type\n",
            "    % (error_string, penalty, loss, dual)\n",
            "ValueError: Unsupported set of arguments: The combination of penalty='l1' and loss='squared_hinge' are not supported when dual=True, Parameters: penalty='l1', loss='squared_hinge', dual=True\n",
            "\n",
            "  warnings.warn(some_fits_failed_message, FitFailedWarning)\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/model_selection/_search.py:972: UserWarning: One or more of the test scores are non-finite: [       nan 0.80454167        nan 0.806375          nan 0.78325\n",
            "        nan 0.81454167        nan 0.78391667        nan 0.816375\n",
            "        nan 0.78829167        nan 0.81633333        nan 0.78895833\n",
            "        nan 0.81629167        nan 0.78908333        nan 0.81641667\n",
            "        nan 0.78891667        nan 0.81629167        nan 0.78945833\n",
            "        nan 0.8085    ]\n",
            "  category=UserWarning,\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best score: 0.8164\n",
            "Best hyperparameters: {'C': 1, 'loss': 'squared_hinge', 'penalty': 'l2'}\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an instance of the class LinearSVC with specific selection of hyperparameters\n",
        "lsvc_ccd_scaled = LinearSVC(penalty=lsvc_grid_search_cv_scaled.best_params_['penalty'], \n",
        "                            loss=lsvc_grid_search_cv_scaled.best_params_['loss'], \n",
        "                            C=lsvc_grid_search_cv_scaled.best_params_['C'], \n",
        "                            max_iter=n_max_iter)\n",
        "\n",
        "# Fit the model\n",
        "calibrated_classifier_cv = CalibratedClassifierCV(lsvc_ccd_scaled) \n",
        "calibrated_classifier_cv.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "# Predict outcomes in the training and testing subsamples and calculate accuracy using optimal probability threshold\n",
        "y_scaled_pred_test = (calibrated_classifier_cv.predict_proba(X_scaled_test)[:,1] > optimal_threshold).astype(int)\n",
        "print(f'Accuracy: {metrics.accuracy_score(y_scaled_test,y_scaled_pred_test):.4f}')\n",
        "\n",
        "# Store classification metrics for KNN\n",
        "lsvc_classification_metrics = classification_metrics(y_scaled_test, y_scaled_pred_test)\n",
        "\n",
        "# Display cross-validation scores for the testing subsample\n",
        "print(classification_report(y_scaled_test, y_scaled_pred_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iMk9dMhgTRzC",
        "outputId": "269e20ef-1388-4aae-fc75-14d5a10444b0"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7720\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.87      0.84      0.85      4687\n",
            "           1       0.48      0.54      0.51      1313\n",
            "\n",
            "    accuracy                           0.77      6000\n",
            "   macro avg       0.67      0.69      0.68      6000\n",
            "weighted avg       0.78      0.77      0.78      6000\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/svm/_base.py:1208: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
            "  ConvergenceWarning,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the confusion matrix (testing subsample)\n",
        "plt.figure(figsize=(10,8))\n",
        "lsvc_ccd_confusion_scaled_test = confusion_matrix(y_scaled_test,y_scaled_pred_test)\n",
        "sns.heatmap(lsvc_ccd_confusion_scaled_test, annot=True, annot_kws={'size':24}, cmap='coolwarm', fmt='d', \n",
        "            xticklabels = ['Non-default', 'Default'], \n",
        "            yticklabels = ['Non-default', 'Default'])\n",
        "plt.ylabel('True label')\n",
        "plt.xlabel('Predicted label')\n",
        "plt.title('Confusion Matrix for Linear SVC (Scaled Features): Testing Subsample', size=18)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        },
        "id": "bJBZ-k7Tm34K",
        "outputId": "0382716f-8a26-42f8-9fdc-3d52ac9ca2a1"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2. K-nearest neighbors (KNN)"
      ],
      "metadata": {
        "id": "eCC_qKuhK-5V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n",
        "# Define the cross-validation approach\n",
        "n_cv_knn = 5\n",
        "\n",
        "# Create an instance of the class KNN\n",
        "knn_model = KNeighborsClassifier()\n",
        "\n",
        "# Define the search space for the hyperparameters\n",
        "search_space = dict()\n",
        "search_space['n_neighbors'] = range(1,11)\n",
        "search_space['metric']      = ['euclidean', 'manhattan']\n",
        "\n",
        "# Create an instance of the class GridSearchCV with desired characteristics\n",
        "knn_grid_search_cv_scaled = GridSearchCV(estimator=knn_model, \n",
        "                                         param_grid=search_space, \n",
        "                                         scoring='accuracy', \n",
        "                                         cv=n_cv_knn, \n",
        "                                         n_jobs=-1)\n",
        "\n",
        "# Run the search algorithm and summarize resuts \n",
        "knn_grid_search_cv_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "print(f'Best score: {knn_grid_search_cv_scaled.best_score_:.4f}')\n",
        "print('Best hyperparameters: %s' % knn_grid_search_cv_scaled.best_params_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TrHrC1VnYnN7",
        "outputId": "f6b3c8a7-bca9-4b2c-f520-7aa323e0f6cb"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best score: 0.8130\n",
            "Best hyperparameters: {'metric': 'manhattan', 'n_neighbors': 10}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an instance of the class KNN with specific selection of hyperparameters\n",
        "knn_ccd_scaled = KNeighborsClassifier(n_neighbors=knn_grid_search_cv_scaled.best_params_['n_neighbors'], \n",
        "                                      metric=knn_grid_search_cv_scaled.best_params_['metric'])\n",
        "\n",
        "# Fit the model\n",
        "knn_ccd_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "# Predict outcomes in the testing subsample and calculate accuracy using optimal probability threshold\n",
        "y_scaled_pred_test = (knn_ccd_scaled.predict_proba(X_scaled_test)[:,1] > optimal_threshold).astype(int)\n",
        "print(f'Accuracy: {metrics.accuracy_score(y_scaled_test,y_scaled_pred_test):.4f}')\n",
        "\n",
        "# Store classification metrics for KNN\n",
        "knn_classification_metrics = classification_metrics(y_scaled_test, y_scaled_pred_test)\n",
        "\n",
        "# Display cross-validation scores for the testing subsample\n",
        "print(classification_report(y_scaled_test, y_scaled_pred_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E2hVi3ZOz2yy",
        "outputId": "82ef2a59-c38e-4478-c73d-8e221a98cb4a"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7215\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.87      0.76      0.81      4687\n",
            "           1       0.41      0.59      0.48      1313\n",
            "\n",
            "    accuracy                           0.72      6000\n",
            "   macro avg       0.64      0.67      0.65      6000\n",
            "weighted avg       0.77      0.72      0.74      6000\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10,8))\n",
        "knn_ccd_confusion_scaled_test = confusion_matrix(y_scaled_test,y_scaled_pred_test)\n",
        "sns.heatmap(knn_ccd_confusion_scaled_test, annot=True, annot_kws={'size':24}, cmap='coolwarm', fmt='d', \n",
        "            xticklabels = ['Non-default', 'Default'], \n",
        "            yticklabels = ['Non-default', 'Default'])\n",
        "plt.ylabel('True label')\n",
        "plt.xlabel('Predicted label')\n",
        "plt.title('Confusion Matrix for KNN (Scaled Features): Testing Subsample', size=18)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        },
        "id": "iPSytSF13obn",
        "outputId": "f0215ede-bba1-4990-ea5b-e544675f6c9b"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Decision trees"
      ],
      "metadata": {
        "id": "xpuvgItessrP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.tree import (DecisionTreeClassifier, plot_tree)\n",
        "\n",
        "# Define the cross-validation approach\n",
        "n_cv_dt = 5\n",
        "\n",
        "# Create an instance of the class DecisionTreeClassifier\n",
        "dt_model = DecisionTreeClassifier()\n",
        "\n",
        "# Define the search space for the hyperparameters\n",
        "search_space = dict()\n",
        "search_space['max_depth']        = [2, 3, 4]\n",
        "search_space['max_features']     = [2, 3, 4]\n",
        "search_space['min_samples_leaf'] = [2, 3, 4]\n",
        "search_space['criterion']        = ['gini', 'entropy']\n",
        "\n",
        "# Create an instance of the class RandomizedSearchCV with desired characteristics\n",
        "dt_randomized_search_cv_scaled = RandomizedSearchCV(estimator=dt_model, \n",
        "                                                    param_distributions=search_space, \n",
        "                                                    scoring='accuracy', \n",
        "                                                    cv=n_cv_dt, \n",
        "                                                    n_jobs=-1)\n",
        "\n",
        "# Run the search algorithm and summarize resuts \n",
        "dt_randomized_search_cv_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "print(f'Best score: {dt_randomized_search_cv_scaled.best_score_:.4f}')\n",
        "print('Best hyperparameters: %s' % dt_randomized_search_cv_scaled.best_params_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-TcHybUmS0Cu",
        "outputId": "a4ec117b-beb4-43c4-9913-06ac23fed4c8"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best score: 0.8206\n",
            "Best hyperparameters: {'min_samples_leaf': 3, 'max_features': 3, 'max_depth': 3, 'criterion': 'gini'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an instance of the class DecisionTreeClassifier with specific selection of hyperparameters\n",
        "dt_ccd_scaled = DecisionTreeClassifier(max_depth=dt_randomized_search_cv_scaled.best_params_['max_depth'], \n",
        "                                       max_features=dt_randomized_search_cv_scaled.best_params_['max_features'], \n",
        "                                       min_samples_leaf=dt_randomized_search_cv_scaled.best_params_['min_samples_leaf'],\n",
        "                                       criterion=dt_randomized_search_cv_scaled.best_params_['criterion'])\n",
        "\n",
        "# Fit the model\n",
        "dt_ccd_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "# Predict outcomes in the testing subsamples and calculate accuracy using optimal probability threshold\n",
        "y_scaled_pred_test = (dt_ccd_scaled.predict_proba(X_scaled_test)[:,1] > optimal_threshold).astype(int)\n",
        "print(f'Accuracy: {metrics.accuracy_score(y_scaled_test, y_scaled_pred_test,):.4f}')\n",
        "\n",
        "# Store classification metrics for Decistion Tree\n",
        "dt_classification_metrics = classification_metrics(y_scaled_test, y_scaled_pred_test)\n",
        "\n",
        "print(classification_report(y_scaled_test, y_scaled_pred_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eJwVZbmzAEBP",
        "outputId": "911abde9-9dbb-461d-d7fd-db27407c6eb5"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7618\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.87      0.82      0.84      4687\n",
            "           1       0.46      0.57      0.51      1313\n",
            "\n",
            "    accuracy                           0.76      6000\n",
            "   macro avg       0.67      0.69      0.68      6000\n",
            "weighted avg       0.78      0.76      0.77      6000\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the confusion matrix (testing subsample)\n",
        "plt.figure(figsize=(10,8))\n",
        "dt_ccd_confusion_scaled_test = confusion_matrix(y_scaled_test,y_scaled_pred_test)\n",
        "sns.heatmap(dt_ccd_confusion_scaled_test, annot=True, annot_kws={'size':24}, cmap='coolwarm', fmt='d', \n",
        "            xticklabels = ['Non-default', 'Default'], \n",
        "            yticklabels = ['Non-default', 'Default'])\n",
        "plt.ylabel('True label')\n",
        "plt.xlabel('Predicted label')\n",
        "plt.title('Confusion Matrix for Decision Tree (Scaled Features): Testing Subsample', size=18)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        },
        "id": "XQai0M-1AEmo",
        "outputId": "052bfbce-4213-47fa-effb-9c10cdef9fa0"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. Random forest algorithms"
      ],
      "metadata": {
        "id": "jmcpTHNFLMaY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "# Define the cross-validation approach\n",
        "n_cv_rf = 5\n",
        "\n",
        "# Create an instance of the class RandomForestClassifier\n",
        "rf_model = RandomForestClassifier()\n",
        "\n",
        "# Define the search space for the hyperparameters\n",
        "search_space = dict()\n",
        "search_space['n_estimators']     = [50, 100, 150, 200, 250]\n",
        "search_space['max_depth']        = [2, 3, 4]\n",
        "search_space['max_features']     = [2, 3, 4]\n",
        "search_space['min_samples_leaf'] = [2, 3, 4]\n",
        "search_space['criterion']        = ['gini', 'entropy']\n",
        "\n",
        "# Create an instance of the class RandomizedSearchCV with desired characteristics\n",
        "rf_randomized_search_cv_scaled = RandomizedSearchCV(estimator=rf_model, \n",
        "                                                    param_distributions=search_space, \n",
        "                                                    scoring='accuracy', \n",
        "                                                    cv=n_cv_rf, \n",
        "                                                    n_jobs=-1)\n",
        "\n",
        "# Run the search algorithm and summarize resuts \n",
        "rf_randomized_search_cv_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "print(f'Best score: {rf_randomized_search_cv_scaled.best_score_:.4f}')\n",
        "print('Best hyperparameters: %s' % rf_randomized_search_cv_scaled.best_params_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4AcSKYbwHgX3",
        "outputId": "a10bb9bb-ef48-4574-8ffb-61340d38d877"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best score: 0.8205\n",
            "Best hyperparameters: {'n_estimators': 200, 'min_samples_leaf': 3, 'max_features': 2, 'max_depth': 3, 'criterion': 'entropy'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an instance of the class RandomForestClassifier with specific selection of hyperparameters\n",
        "rf_ccd_scaled = RandomForestClassifier(n_estimators=rf_randomized_search_cv_scaled.best_params_['n_estimators'], \n",
        "                                       max_depth=rf_randomized_search_cv_scaled.best_params_['max_depth'], \n",
        "                                       max_features=rf_randomized_search_cv_scaled.best_params_['max_features'], \n",
        "                                       min_samples_leaf=rf_randomized_search_cv_scaled.best_params_['min_samples_leaf'],\n",
        "                                       criterion=rf_randomized_search_cv_scaled.best_params_['criterion'])\n",
        "\n",
        "# Fit the model\n",
        "rf_ccd_scaled.fit(X_scaled_train, y_scaled_train)\n",
        "\n",
        "# Predict outcomes in the testing subsamples and calculate accuracy using optimal probability threshold\n",
        "y_scaled_pred_test = (rf_ccd_scaled.predict_proba(X_scaled_test)[:,1] > optimal_threshold).astype(int)\n",
        "\n",
        "# Store classification metrics for KNN\n",
        "rf_classification_metrics = classification_metrics(y_scaled_test, y_scaled_pred_test)\n",
        "\n",
        "print(f'Accuracy: {metrics.accuracy_score(y_scaled_test,y_scaled_pred_test):.4f}')\n",
        "print(classification_report(y_scaled_test, y_scaled_pred_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sZgMN2ddKpLL",
        "outputId": "a28bc96c-6736-4530-8d14-ecdfdcf5029b"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7653\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.87      0.82      0.85      4687\n",
            "           1       0.47      0.57      0.52      1313\n",
            "\n",
            "    accuracy                           0.77      6000\n",
            "   macro avg       0.67      0.70      0.68      6000\n",
            "weighted avg       0.78      0.77      0.77      6000\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tabular comparison of Classification Methods\n",
        "\n",
        "Let's compare 5 different Classification Methods and their metrics. \n",
        "\n",
        "The optimal probability threshold that has been used is: 0.217658."
      ],
      "metadata": {
        "id": "SmECJaaEEL_B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classification Metrics for all Methods (testing sample)"
      ],
      "metadata": {
        "id": "bQ3CwUNhnTbF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lsvc_classification_metrics"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4K3w1SJXnKnt",
        "outputId": "5b4dfeaf-8939-4e9e-9d53-fbe060dff536"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Accuraccy': 0.772,\n",
              " 'F1': 0.5103793843951324,\n",
              " 'Precision': 0.543031226199543,\n",
              " 'Recall': 0.4814314652261985}"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "knn_classification_metrics"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-BtO0IMHLho5",
        "outputId": "f618e078-2101-49a9-8ffe-15a2946c8638"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Accuraccy': 0.7215,\n",
              " 'F1': 0.48024883359253495,\n",
              " 'Precision': 0.587966488956588,\n",
              " 'Recall': 0.4058885383806519}"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dt_classification_metrics"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cbt9rNZ9MIY_",
        "outputId": "ee1efc79-1e47-4862-eaff-3a34e3468cee"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Accuraccy': 0.7618333333333334,\n",
              " 'F1': 0.5117868124359413,\n",
              " 'Precision': 0.5704493526275705,\n",
              " 'Recall': 0.46406443618339527}"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rf_classification_metrics"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6AtKhQTWONJ_",
        "outputId": "476f8b6b-586b-4648-ca12-669b9045cbac"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Accuraccy': 0.7653333333333333,\n",
              " 'F1': 0.5154852030282175,\n",
              " 'Precision': 0.5704493526275705,\n",
              " 'Recall': 0.4701820464532329}"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tabular presentation"
      ],
      "metadata": {
        "id": "cgCQhs-InpPs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "| Method/Metric | Accuracy | Precision | Recall | F1 |\n",
        "| --- | --- | --- | --- | --- |\n",
        "| Logistic Regression | 0.7713 | 0.4803 | 0.5484 | 0.5121\n",
        "| Linear SVC | 0.7720 | 0.5430 | 0.4814 | 0.5104\n",
        "| K-nearest Neighbors | 0.7215 | 0.5880 | 0.4059 | 0.4803\n",
        "| Decision Tree | 0.7618 | 0.5704 | 0.4641 | 0.5118\n",
        "| Random Forrest | 0.7653 | 0.5704 | 0.4702 | 0.5155"
      ],
      "metadata": {
        "id": "ezZXi3vHJkUN"
      }
    }
  ]
}