DefaultPrediction_Part_3_DeepLearning_2007_2018.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wSzGi_xJgYfZ"
      },
      "source": [
        "*CREDIT DEFAULT PREDICTION:* **Part III - DeepLearning**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDf566Wogv7V"
      },
      "source": [
        "## Acknowledgement"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p4FyseLhg3yJ"
      },
      "source": [
        "Predicting Loan Defaults using Deep Learning with Keras & Tensorflow Sarathi Balakrishnan\n",
        "\n",
        "Sarathi Balakrishnan\n",
        "Sarathi Balakrishnan\n",
        "Entrepreneur & tech enthusiast with hands on experience in variety of technology from private cloud architecting to Bigdata, Analytics, AI and ML.\n",
        "\n",
        "https://sarathi-tech.medium.com/predicting-loan-defaults-using-deep-learning-with-keras-tensorflow-78a15b196e65\n",
        "\n",
        "And, here is some information on how to use Dropouts\n",
        "https://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/\n",
        "\n",
        "And the nature of neural networks: https://machinelearningmastery.com/reproducible-results-neural-networks-keras/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B4FqdAzFiNRU"
      },
      "source": [
        "## Begin"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0MBU5zeCfsT5"
      },
      "outputs": [],
      "source": [
        "# import libraries\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense,Dropout\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from tensorflow.keras.models import load_model\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "from pickle import dump, load"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0mqPwEAphOKd"
      },
      "source": [
        "Download balanced sample created in part I"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TvBCNcmhhGGS"
      },
      "outputs": [],
      "source": [
        "df = pd.read_csv('https://github.com/coyoacan/abc/blob/99ae3b10000a039739a129c49a8112ed17e4293b/DefaultPrediction_balanced_sample_2007_2018.zip?raw=true', compression='zip', encoding='utf-8')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6m5uxHU0htNz"
      },
      "outputs": [],
      "source": [
        "from timeit import default_timer # measure processing time :)\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder, MinMaxScaler, StandardScaler\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.metrics import ConfusionMatrixDisplay\n",
        "from sklearn import metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHfuPEFIhSYa"
      },
      "source": [
        "Some transformations again"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8vpKYIQuhX9z",
        "outputId": "b5d00264-808c-4602-a957-c275e8488a47"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 33040 entries, 0 to 33039\n",
            "Data columns (total 23 columns):\n",
            " #   Column                Non-Null Count  Dtype   \n",
            "---  ------                --------------  -----   \n",
            " 0   loan_amnt             33040 non-null  int64   \n",
            " 1   int_rate              33040 non-null  float64 \n",
            " 2   installment           33040 non-null  float64 \n",
            " 3   annual_inc            33040 non-null  float64 \n",
            " 4   dti                   33031 non-null  float64 \n",
            " 5   open_acc              33040 non-null  int64   \n",
            " 6   pub_rec               33040 non-null  int64   \n",
            " 7   revol_bal             33040 non-null  int64   \n",
            " 8   revol_util            33022 non-null  float64 \n",
            " 9   total_acc             33040 non-null  int64   \n",
            " 10  mort_acc              31900 non-null  float64 \n",
            " 11  pub_rec_bankruptcies  33029 non-null  float64 \n",
            " 12  term                  33040 non-null  category\n",
            " 13  sub_grade             33040 non-null  category\n",
            " 14  emp_title             30536 non-null  category\n",
            " 15  emp_length            30712 non-null  category\n",
            " 16  home_ownership        33040 non-null  category\n",
            " 17  verification_status   33040 non-null  category\n",
            " 18  purpose               33040 non-null  category\n",
            " 19  title                 32558 non-null  category\n",
            " 20  zip_code              33040 non-null  category\n",
            " 21  addr_state            33040 non-null  category\n",
            " 22  loan_status           33040 non-null  category\n",
            "dtypes: category(11), float64(7), int64(5)\n",
            "memory usage: 4.2 MB\n"
          ]
        }
      ],
      "source": [
        "new_cols = [col for col in df.columns if col != 'loan_status'] + ['loan_status']\n",
        "df = df[new_cols] # new column order where target appears last\n",
        "df = pd.concat([\n",
        "        df.select_dtypes([], ['object']),\n",
        "        df.select_dtypes(['object']).apply(pd.Series.astype, dtype='category')\n",
        "        ], axis=1)\n",
        "df.info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B0GZynYzhnAR"
      },
      "outputs": [],
      "source": [
        "X = df.drop('loan_status',axis=1)\n",
        "y = df['loan_status']\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=2022)\n",
        "\n",
        "attributes_number = Pipeline(steps=[\n",
        "    ('null_replacement', SimpleImputer(strategy='mean')),\n",
        "    ('scaling', StandardScaler())\n",
        "])\n",
        "\n",
        "attributes_category = Pipeline(steps=[\n",
        "    ('null_replacement', SimpleImputer(strategy='most_frequent')),\n",
        "    ('encoding', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value = -1))\n",
        "])\n",
        "\n",
        "columns_number = X_train.select_dtypes(include='number').columns.to_list()\n",
        "columns_category = X_train.select_dtypes(include='category').columns.to_list()\n",
        "\n",
        "attributes_preprocess = ColumnTransformer(transformers=[\n",
        "    ('number', attributes_number, columns_number),\n",
        "    ('category', attributes_category, columns_category)\n",
        "])\n",
        "\n",
        "# Prepare Y set before using the model\n",
        "label_encoding = LabelEncoder()\n",
        "y_train = label_encoding.fit_transform(y_train)\n",
        "y_test = label_encoding.fit_transform(y_test)\n",
        "\n",
        "# Prepare X set before using the model in case we need it\n",
        "pX_train = attributes_preprocess.fit_transform(X_train)\n",
        "pX_test = attributes_preprocess.fit_transform(X_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GVPfNiGRjkb9"
      },
      "source": [
        "## Building our Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4UHiSnZY2Nrm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6bb5fa1f-20f6-4db9-f480-d6224e5f9c7e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: scikeras[tensorflow] in /usr/local/lib/python3.10/dist-packages (0.10.0)\n",
            "Requirement already satisfied: packaging>=0.21 in /usr/local/lib/python3.10/dist-packages (from scikeras[tensorflow]) (23.1)\n",
            "Requirement already satisfied: scikit-learn>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from scikeras[tensorflow]) (1.2.2)\n",
            "Requirement already satisfied: tensorflow>=2.11.0 in /usr/local/lib/python3.10/dist-packages (from scikeras[tensorflow]) (2.12.0)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.0->scikeras[tensorflow]) (1.22.4)\n",
            "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.0->scikeras[tensorflow]) (1.10.1)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.0->scikeras[tensorflow]) (1.2.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.0->scikeras[tensorflow]) (3.1.0)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=2.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (23.3.3)\n",
            "Requirement already satisfied: gast<=0.4.0,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (0.4.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (0.2.0)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (1.54.0)\n",
            "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (3.8.0)\n",
            "Requirement already satisfied: jax>=0.3.15 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (0.4.8)\n",
            "Requirement already satisfied: keras<2.13,>=2.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (2.12.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (16.0.0)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (3.3.0)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (3.20.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (67.7.2)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (1.16.0)\n",
            "Requirement already satisfied: tensorboard<2.13,>=2.12 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (2.12.2)\n",
            "Requirement already satisfied: tensorflow-estimator<2.13,>=2.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (2.12.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (2.3.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (4.5.0)\n",
            "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (1.14.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow>=2.11.0->scikeras[tensorflow]) (0.32.0)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow>=2.11.0->scikeras[tensorflow]) (0.40.0)\n",
            "Requirement already satisfied: ml-dtypes>=0.0.3 in /usr/local/lib/python3.10/dist-packages (from jax>=0.3.15->tensorflow>=2.11.0->scikeras[tensorflow]) (0.1.0)\n",
            "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2.17.3)\n",
            "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (1.0.0)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (3.4.3)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2.27.1)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (0.7.0)\n",
            "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (1.8.1)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2.3.0)\n",
            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (5.3.0)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (0.3.0)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (4.9)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (1.3.1)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (1.26.15)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2022.12.7)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (3.4)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (2.1.2)\n",
            "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (0.5.0)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.13,>=2.12->tensorflow>=2.11.0->scikeras[tensorflow]) (3.2.2)\n"
          ]
        }
      ],
      "source": [
        "# Normal tensorflow\n",
        "!pip install scikeras[tensorflow]"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# following seeds help us to diminish randomness in our NNs\n",
        "from numpy.random import seed\n",
        "seed(1)\n",
        "import tensorflow\n",
        "tensorflow.random.set_seed(2)"
      ],
      "metadata": {
        "id": "03Csru6q7AvP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JSjC4VqfjyWg"
      },
      "outputs": [],
      "source": [
        "from scikeras.wrappers import KerasClassifier\n",
        "def create_model():\n",
        "  model = Sequential()\n",
        "\n",
        "  model.add(Dense(18, input_shape=(22,), activation='relu'))\n",
        "  model.add(Dense(10, activation='relu'))\n",
        "  model.add(Dense(6, activation='relu'))\n",
        "  model.add(Dense(1, activation='sigmoid'))\n",
        "  model.compile(optimizer='adam', \n",
        "          loss='binary_crossentropy', \n",
        "          metrics=['accuracy'])\n",
        "  return model\n",
        "\n",
        "network_model = KerasClassifier(model=create_model, epochs=200, batch_size=150, verbose=0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SErYfN6r_27Z"
      },
      "source": [
        "Next piece of code takes about 3 minutes to complete. Model with no dropouts, I'm using a wrapper (KerasClassifier) to use scikit-learn pipeline with a Keras Model. Before using KerasClassifier intall SciKeras in your environment. Advise: run this part a few times before selecting the right model. Our friend, Jason Brownlee would say \"Neural network algorithms are stochastic. This means they make use of randomness, such as initializing to random weights, and in turn the same network trained on the same data can produce different results.\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Ibbtql4XkViF",
        "outputId": "3014dd39-bc55-419b-d0e7-f17fcab0aa36"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mean accuracy (train):  0.6488239363542027\n",
            "mean accuracy (test):  0.6078490718321227\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.59      0.75      0.66      4978\n",
            "           1       0.65      0.47      0.54      4934\n",
            "\n",
            "    accuracy                           0.61      9912\n",
            "   macro avg       0.62      0.61      0.60      9912\n",
            "weighted avg       0.62      0.61      0.60      9912\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f84f9a2e5f0>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#set up plotting area\n",
        "plt.figure(0).clf()\n",
        "\n",
        "# fit Decision network classifier\n",
        "model_pipeline = Pipeline(steps=[\n",
        "                                  ('preprocesss', attributes_preprocess),\n",
        "                                  ('model', network_model)                                 \n",
        "])\n",
        "\n",
        "\n",
        "model_pipeline.fit(X_train, y_train)\n",
        "\n",
        "y_pred = model_pipeline.predict(X_test)\n",
        "print(\"mean accuracy (train): \", model_pipeline.score(X_train,y_train))\n",
        "print(\"mean accuracy (test): \", model_pipeline.score(X_test,y_test))\n",
        "print(classification_report(y_test,y_pred))\n",
        "\n",
        "ConfusionMatrixDisplay.from_predictions(y_test,y_pred, xticks_rotation='vertical')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "y_pred = model_pipeline.predict_proba(X_test)[:, 1]\n",
        "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred)\n",
        "auc = round(metrics.roc_auc_score(y_test, y_pred), 4)\n",
        "plt.plot(fpr,tpr,label=\"NETWORK, AUC=\"+str(auc))\n",
        "#add legend\n",
        "plt.ylabel('True Positive Rate (Sensitivity)')\n",
        "plt.xlabel('False Positive Rate (Specificity)')\n",
        "plt.legend(loc=4,prop={'size': 12})"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make a Copy of Original model prediction for y_train\n",
        "y_train_predicted = model_pipeline.predict(X_train)"
      ],
      "metadata": {
        "id": "D0kwpRMAShJb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Handling False Positives"
      ],
      "metadata": {
        "id": "bKikztPG0B_Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "I took some ideas from this girl Sanskriti Singh\n",
        "https://medium.com/@Sanskriti.Singh/an-emphasis-on-the-minimization-of-false-negatives-false-positives-in-binary-classification-9c22f3f9f73\n",
        "\n",
        "\"To minimize the number of False Negatives (FN) or False Positives (FP) we can also retrain a model on the same data with slightly different output values more specific to its previous results. This method involves taking a model and training it on a dataset until it optimally reaches a global minimum. If we were trying to minimize False Negatives, we would take some amount (independent variable) of the False Positives on the training data and change their real value to 1.\""
      ],
      "metadata": {
        "id": "aO-cn2z05xdG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check lengths, both should be the same\n",
        "print(\"Y train predicted length is: \", len(y_train_predicted))\n",
        "print(\"Original Y train length is: \", len(y_train))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mhydk32NB1jp",
        "outputId": "0b1d3df0-f987-4b22-9682-b7478960b9d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Y train predicted length is:  23128\n",
            "Original Y train length is:  23128\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# zip both lists for quick comparison\n",
        "c = list(zip(y_train,y_train_predicted))\n",
        "# get positions where y_train is 0 and y_train predicted is 1\n",
        "case_list = [i for i, x in enumerate(c) if x==(1,0)]"
      ],
      "metadata": {
        "id": "C9y9-WOfCiwk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import random \n",
        "import random"
      ],
      "metadata": {
        "id": "JzjiyNMqI-tN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# randomly select 20% of total cases\n",
        "case_list_shortened = random.sample(case_list,round(len(case_list)*0.2))"
      ],
      "metadata": {
        "id": "w9rmj2pKDcqO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_y_train = y_train.copy() # copy old y_train\n",
        "for x in case_list_shortened:\n",
        "    new_y_train[x] = 0"
      ],
      "metadata": {
        "id": "KYoB3t9_LOJk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10): # Validation\n",
        "  print(\"Change validation #\",i,\"(y_train vs new_y_train) \", \n",
        "        y_train[case_list_shortened[i]],new_y_train[case_list_shortened[i]])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CBliqJzdNWin",
        "outputId": "95a21ea6-82cd-42cc-bc47-98e0895e8999"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Change validation # 0 (y_train vs new_y_train)  1 0\n",
            "Change validation # 1 (y_train vs new_y_train)  1 0\n",
            "Change validation # 2 (y_train vs new_y_train)  1 0\n",
            "Change validation # 3 (y_train vs new_y_train)  1 0\n",
            "Change validation # 4 (y_train vs new_y_train)  1 0\n",
            "Change validation # 5 (y_train vs new_y_train)  1 0\n",
            "Change validation # 6 (y_train vs new_y_train)  1 0\n",
            "Change validation # 7 (y_train vs new_y_train)  1 0\n",
            "Change validation # 8 (y_train vs new_y_train)  1 0\n",
            "Change validation # 9 (y_train vs new_y_train)  1 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Re-train and look at the results"
      ],
      "metadata": {
        "id": "wegqEEZYOojk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#set up plotting area\n",
        "plt.figure(0).clf()\n",
        "\n",
        "# fit Decision network classifier\n",
        "model_pipeline = Pipeline(steps=[\n",
        "                                  ('preprocesss', attributes_preprocess),\n",
        "                                  ('model', network_model)                                 \n",
        "])\n",
        "\n",
        "\n",
        "model_pipeline.fit(X_train, new_y_train) # use new_y_train here!!!!!\n",
        "\n",
        "y_pred = model_pipeline.predict(X_test)\n",
        "print(\"mean accuracy (train): \", model_pipeline.score(X_train,y_train))\n",
        "print(\"mean accuracy (test): \", model_pipeline.score(X_test,y_test))\n",
        "print(classification_report(y_test,y_pred))\n",
        "\n",
        "ConfusionMatrixDisplay.from_predictions(y_test,y_pred, xticks_rotation='vertical')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "y_pred = model_pipeline.predict_proba(X_test)[:, 1]\n",
        "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred)\n",
        "auc = round(metrics.roc_auc_score(y_test, y_pred), 4)\n",
        "plt.plot(fpr,tpr,label=\"NETWORK, AUC=\"+str(auc))\n",
        "#add legend\n",
        "plt.ylabel('True Positive Rate (Sensitivity)')\n",
        "plt.xlabel('False Positive Rate (Specificity)')\n",
        "plt.legend(loc=4,prop={'size': 12})"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "PrXMtrDMOhCb",
        "outputId": "f3afe0f9-6d49-4f87-bc02-75677e795814"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mean accuracy (train):  0.6122881355932204\n",
            "mean accuracy (test):  0.5900928167877321\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.56      0.81      0.67      4978\n",
            "           1       0.66      0.37      0.47      4934\n",
            "\n",
            "    accuracy                           0.59      9912\n",
            "   macro avg       0.61      0.59      0.57      9912\n",
            "weighted avg       0.61      0.59      0.57      9912\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f84f9a740a0>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "V100"
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}