financial_distress_prediction.ipynb

{
  "cells": [
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import pandas as pd\nimport numpy as np",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import matplotlib.pyplot as plt\nimport seaborn as sns\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.dummy import DummyClassifier\nfrom sklearn.metrics import accuracy_score, f1_score, confusion_matrix, recall_score",
      "execution_count": 2,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "data=pd.read_csv('Financial Distress.csv')",
      "execution_count": 3,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "data.head()",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 4,
          "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>Company</th>\n      <th>Time</th>\n      <th>x1</th>\n      <th>x2</th>\n      <th>x3</th>\n      <th>x4</th>\n      <th>x5</th>\n      <th>x6</th>\n      <th>x7</th>\n      <th>x8</th>\n      <th>...</th>\n      <th>x75</th>\n      <th>x76</th>\n      <th>x77</th>\n      <th>x78</th>\n      <th>x79</th>\n      <th>x80</th>\n      <th>x81</th>\n      <th>x82</th>\n      <th>x83</th>\n      <th>Financial Distress</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>1</td>\n      <td>1.2810</td>\n      <td>0.022934</td>\n      <td>0.87454</td>\n      <td>1.21640</td>\n      <td>0.060940</td>\n      <td>0.188270</td>\n      <td>0.52510</td>\n      <td>0.018854</td>\n      <td>...</td>\n      <td>27.07</td>\n      <td>26.102</td>\n      <td>16.000</td>\n      <td>16.0</td>\n      <td>0.2</td>\n      <td>22</td>\n      <td>0.060390</td>\n      <td>30</td>\n      <td>49</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>2</td>\n      <td>1.2700</td>\n      <td>0.006454</td>\n      <td>0.82067</td>\n      <td>1.00490</td>\n      <td>-0.014080</td>\n      <td>0.181040</td>\n      <td>0.62288</td>\n      <td>0.006423</td>\n      <td>...</td>\n      <td>31.31</td>\n      <td>30.194</td>\n      <td>17.000</td>\n      <td>16.0</td>\n      <td>0.4</td>\n      <td>22</td>\n      <td>0.010636</td>\n      <td>31</td>\n      <td>50</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>3</td>\n      <td>1.0529</td>\n      <td>-0.059379</td>\n      <td>0.92242</td>\n      <td>0.72926</td>\n      <td>0.020476</td>\n      <td>0.044865</td>\n      <td>0.43292</td>\n      <td>-0.081423</td>\n      <td>...</td>\n      <td>36.07</td>\n      <td>35.273</td>\n      <td>17.000</td>\n      <td>15.0</td>\n      <td>-0.2</td>\n      <td>22</td>\n      <td>-0.455970</td>\n      <td>32</td>\n      <td>51</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>4</td>\n      <td>1.1131</td>\n      <td>-0.015229</td>\n      <td>0.85888</td>\n      <td>0.80974</td>\n      <td>0.076037</td>\n      <td>0.091033</td>\n      <td>0.67546</td>\n      <td>-0.018807</td>\n      <td>...</td>\n      <td>39.80</td>\n      <td>38.377</td>\n      <td>17.167</td>\n      <td>16.0</td>\n      <td>5.6</td>\n      <td>22</td>\n      <td>-0.325390</td>\n      <td>33</td>\n      <td>52</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2</td>\n      <td>1</td>\n      <td>1.0623</td>\n      <td>0.107020</td>\n      <td>0.81460</td>\n      <td>0.83593</td>\n      <td>0.199960</td>\n      <td>0.047800</td>\n      <td>0.74200</td>\n      <td>0.128030</td>\n      <td>...</td>\n      <td>27.07</td>\n      <td>26.102</td>\n      <td>16.000</td>\n      <td>16.0</td>\n      <td>0.2</td>\n      <td>29</td>\n      <td>1.251000</td>\n      <td>7</td>\n      <td>27</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n<p>5 rows × 86 columns</p>\n</div>",
            "text/plain": "   Company  Time      x1        x2       x3       x4        x5        x6  \\\n0        1     1  1.2810  0.022934  0.87454  1.21640  0.060940  0.188270   \n1        1     2  1.2700  0.006454  0.82067  1.00490 -0.014080  0.181040   \n2        1     3  1.0529 -0.059379  0.92242  0.72926  0.020476  0.044865   \n3        1     4  1.1131 -0.015229  0.85888  0.80974  0.076037  0.091033   \n4        2     1  1.0623  0.107020  0.81460  0.83593  0.199960  0.047800   \n\n        x7        x8         ...            x75     x76     x77   x78  x79  \\\n0  0.52510  0.018854         ...          27.07  26.102  16.000  16.0  0.2   \n1  0.62288  0.006423         ...          31.31  30.194  17.000  16.0  0.4   \n2  0.43292 -0.081423         ...          36.07  35.273  17.000  15.0 -0.2   \n3  0.67546 -0.018807         ...          39.80  38.377  17.167  16.0  5.6   \n4  0.74200  0.128030         ...          27.07  26.102  16.000  16.0  0.2   \n\n   x80       x81  x82  x83  Financial Distress  \n0   22  0.060390   30   49                   0  \n1   22  0.010636   31   50                   0  \n2   22 -0.455970   32   51                   0  \n3   22 -0.325390   33   52                   1  \n4   29  1.251000    7   27                   0  \n\n[5 rows x 86 columns]"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "data.columns",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 5,
          "data": {
            "text/plain": "Index(['Company', 'Time', 'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9',\n       'x10', 'x11', 'x12', 'x13', 'x14', 'x15', 'x16', 'x17', 'x18', 'x19',\n       'x20', 'x21', 'x22', 'x23', 'x24', 'x25', 'x26', 'x27', 'x28', 'x29',\n       'x30', 'x31', 'x32', 'x33', 'x34', 'x35', 'x36', 'x37', 'x38', 'x39',\n       'x40', 'x41', 'x42', 'x43', 'x44', 'x45', 'x46', 'x47', 'x48', 'x49',\n       'x50', 'x51', 'x52', 'x53', 'x54', 'x55', 'x56', 'x57', 'x58', 'x59',\n       'x60', 'x61', 'x62', 'x63', 'x64', 'x65', 'x66', 'x67', 'x68', 'x69',\n       'x70', 'x71', 'x72', 'x73', 'x74', 'x75', 'x76', 'x77', 'x78', 'x79',\n       'x80', 'x81', 'x82', 'x83', 'Financial Distress'],\n      dtype='object')"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "data['Financial Distress'].value_counts()",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 6,
          "data": {
            "text/plain": "0    3536\n1     136\nName: Financial Distress, dtype: int64"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "X, y = data.loc[:,data.columns!='Financial Distress'], data.loc[:,'Financial Distress'].values\nfrom sklearn.model_selection import train_test_split\nX_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=123,stratify=data['Financial Distress'])",
      "execution_count": 7,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# We have used stratified above to split the data distribution in equal manner\nprint(pd.value_counts(y_train)/y_train.size * 100)\nprint(pd.value_counts(y_test)/y_test.size * 100)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0    96.303502\n1     3.696498\ndtype: float64\n0    96.279492\n1     3.720508\ndtype: float64\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Importing KNN module from PyOD\nfrom pyod.models.knn import KNN",
      "execution_count": 10,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Train kNN detector\nclf = KNN(contamination=0.02, n_neighbors=5)\nclf.fit(X_train)",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 11,
          "data": {
            "text/plain": "KNN(algorithm='auto', contamination=0.02, leaf_size=30, method='largest',\n  metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n  radius=1.0)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Get the prediction labels of the training data\ny_train_pred = clf.labels_ \n\n# Outlier scores\ny_train_scores = clf.decision_scores_  ",
      "execution_count": 12,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from pyod.utils import evaluate_print\n\n# Evaluate on the training data\nevaluate_print('KNN', y_train, y_train_scores)",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "KNN ROC:0.4627, precision @ rank n:0.0211\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "unique, counts = np.unique(y_train_pred, return_counts=True)",
      "execution_count": 14,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "unique,counts",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 15,
          "data": {
            "text/plain": "(array([0, 1]), array([2518,   52]))"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "Accuracy is not the best metric to use when evaluating imbalanced datasets as it can be misleading. Metrics that can provide better insight include:\n\n    Confusion Matrix: a talbe showing correct predictions and types of incorrect predictions.\n    Precision: the number of true positives divided by all positive predictions. Precision is also called Positive Predictive Value. It is a measure of a classifier's exactness. Low precision indicates a high number of false positives.\n    Recall: the number of true positives divided by the number of positive values in the test data. Recall is also called Sensitivity or the True Positive Rate. It is a measure of a classifier's completeness. Low recall indicates a high number of false negatives.\n    F1: Score: the weighted average of precision and recall.\n\nSince our main objective with the dataset is to prioritize accuraltely classifying financial instability cases the recall score can be considered our main metric to use for evaluating outcomes."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Trying different algorithm"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from sklearn.ensemble import RandomForestClassifier\n# train model\nrfc = RandomForestClassifier(n_estimators=10).fit(X_train, y_train)\n\n# predict on test set\nrfc_pred = rfc.predict(X_test)\n\naccuracy_score(y_test, rfc_pred)",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 16,
          "data": {
            "text/plain": "0.9637023593466425"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# f1 score\nf1_score(y_test, rfc_pred, average='weighted')\n",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 17,
          "data": {
            "text/plain": "0.95452821664783"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# confusion matrix\npd.DataFrame(confusion_matrix(y_test, rfc_pred))",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 18,
          "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>0</th>\n      <th>1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1055</td>\n      <td>6</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>34</td>\n      <td>7</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "      0  1\n0  1055  6\n1    34  7"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# recall score\nrecall_score(y_test, rfc_pred)",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 19,
          "data": {
            "text/plain": "0.17073170731707318"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Oversampling Minority Class\n\nOversampling can be defined as adding more copies of the minority class. Oversampling can be a good choice when you don't have a ton of data to work with. A con to consider when undersampling is that it can cause overfitting and poor generalization to your test set.\n\nWe will use the resampling module from Scikit-Learn to randomly replicate samples from the minority class.\nImportant Note\n\nAlways split into test and train sets BEFORE trying any resampling techniques! Oversampling before splitting the data can allow the exact same observations to be present in both the test and train sets! This can allow our model to simply memorize specific data points and cause overfitting."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from sklearn.utils import resample\n",
      "execution_count": 20,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "X['class']=y",
      "execution_count": 21,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "X.columns",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 22,
          "data": {
            "text/plain": "Index(['Company', 'Time', 'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9',\n       'x10', 'x11', 'x12', 'x13', 'x14', 'x15', 'x16', 'x17', 'x18', 'x19',\n       'x20', 'x21', 'x22', 'x23', 'x24', 'x25', 'x26', 'x27', 'x28', 'x29',\n       'x30', 'x31', 'x32', 'x33', 'x34', 'x35', 'x36', 'x37', 'x38', 'x39',\n       'x40', 'x41', 'x42', 'x43', 'x44', 'x45', 'x46', 'x47', 'x48', 'x49',\n       'x50', 'x51', 'x52', 'x53', 'x54', 'x55', 'x56', 'x57', 'x58', 'x59',\n       'x60', 'x61', 'x62', 'x63', 'x64', 'x65', 'x66', 'x67', 'x68', 'x69',\n       'x70', 'x71', 'x72', 'x73', 'x74', 'x75', 'x76', 'x77', 'x78', 'x79',\n       'x80', 'x81', 'x82', 'x83', 'class'],\n      dtype='object')"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# separate minority and majority classes\nnot_distress = X[X['class']==0]\ndistress = X[X['class']==1]\n\n# upsample minority\nfraud_upsampled = resample(distress,\n                          replace=True, # sample with replacement\n                          n_samples=len(not_distress), # match number in majority class\n                          random_state=27) # reproducible results\n\n# combine majority and upsampled minority\nupsampled = pd.concat([not_distress, fraud_upsampled])\n\n# check new class counts\nupsampled['class'].value_counts()",
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 23,
          "data": {
            "text/plain": "1    3536\n0    3536\nName: class, dtype: int64"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# trying logistic regression again with the balanced dataset\ny_train = upsampled['class']\nX_train = upsampled.drop('class', axis=1)\n\nupsampled = LogisticRegression(solver='liblinear').fit(X_train, y_train)\n\nupsampled_pred = upsampled.predict(X_test)\n",
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": "/home/nbuser/anaconda3_501/lib/python3.6/site-packages/sklearn/svm/base.py:931: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n  \"the number of iterations.\", ConvergenceWarning)\n",
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Checking accuracy\naccuracy_score(y_test, upsampled_pred)",
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 25,
          "data": {
            "text/plain": "0.8112522686025408"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# f1 score\nf1_score(y_test, upsampled_pred, average='weighted')",
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 26,
          "data": {
            "text/plain": "0.8676836378769709"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# confusion matrix\npd.DataFrame(confusion_matrix(y_test, upsampled_pred))",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 27,
          "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>0</th>\n      <th>1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>864</td>\n      <td>197</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>11</td>\n      <td>30</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "     0    1\n0  864  197\n1   11   30"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "recall_score(y_test, upsampled_pred)",
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 28,
          "data": {
            "text/plain": "0.7317073170731707"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Undersampling Majority Class\n\nUndersampling can be defined as removing some observations of the majority class. Undersampling can be a good choice when you have a ton of data -think millions of rows. But a drawback to undersampling is that we are removing information that may be valuable.\n\nWe will again use the resampling module from Scikit-Learn to randomly remove samples from the majority class."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# downsample majority\nnot_fraud_downsampled = resample(not_distress,\n                                replace = False, # sample without replacement\n                                n_samples = len(distress), # match minority n\n                                random_state = 27) # reproducible results\n\n# combine minority and downsampled majority\ndownsampled = pd.concat([not_fraud_downsampled, distress])\n\n# checking counts\ndownsampled['class'].value_counts()",
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 29,
          "data": {
            "text/plain": "1    136\n0    136\nName: class, dtype: int64"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y_train = downsampled['class']\nX_train = downsampled.drop('class', axis=1)\n\nundersampled = LogisticRegression(solver='liblinear').fit(X_train, y_train)\n\nundersampled_pred = undersampled.predict(X_test)",
      "execution_count": 30,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Checking accuracy\naccuracy_score(y_test, undersampled_pred)",
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 31,
          "data": {
            "text/plain": "0.7468239564428312"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# f1 score\nf1_score(y_test, undersampled_pred, average='weighted')",
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 32,
          "data": {
            "text/plain": "0.8254815387502177"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# confusion matrix\npd.DataFrame(confusion_matrix(y_test, undersampled_pred))",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 33,
          "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>0</th>\n      <th>1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>785</td>\n      <td>276</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>3</td>\n      <td>38</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "     0    1\n0  785  276\n1    3   38"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "recall_score(y_test, undersampled_pred)",
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 34,
          "data": {
            "text/plain": "0.926829268292683"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Generate Synthetic Samples\n\nSMOTE or Synthetic Minority Oversampling Technique is a popular algorithm to creates sythetic observations of the minority class."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from imblearn.over_sampling import SMOTE\n\n# Separate input features and target\n#y = data['Financial Distress']\n#X = data.drop('Financial Distress', axis=1)\n\n# setting up testing and training sets\n#X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=27)\n\nsm = SMOTE(random_state=27, ratio=1.0)\nX_train, y_train = sm.fit_sample(X_train, y_train)",
      "execution_count": 35,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "smote = LogisticRegression(solver='liblinear').fit(X_train, y_train)\n\nsmote_pred = smote.predict(X_test)\n\n# Checking accuracy\naccuracy_score(y_test, smote_pred)\n",
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 36,
          "data": {
            "text/plain": "0.7468239564428312"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# f1 score\nf1_score(y_test, smote_pred, average='weighted')\n",
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 37,
          "data": {
            "text/plain": "0.8254815387502177"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# confustion matrix\npd.DataFrame(confusion_matrix(y_test, smote_pred))\n",
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 38,
          "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>0</th>\n      <th>1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>785</td>\n      <td>276</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>3</td>\n      <td>38</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "     0    1\n0  785  276\n1    3   38"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "recall_score(y_test, smote_pred)\n",
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 39,
          "data": {
            "text/plain": "0.926829268292683"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Using class weights"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from sklearn.utils import class_weight",
      "execution_count": 40,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#In order to calculate the class weight do the following\n#class_weights = class_weight.compute_class_weight('imbalanced',\n                                                # np.unique(y_train),\n                                                # y_train)\n#class_weights={0:1,1:200} even can assign manual weights",
      "execution_count": 44,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from collections import Counter\n\ndef get_class_weights(y):\n    counter = Counter(y)\n    majority = max(counter.values())\n    return  {cls: round(float(majority)/float(count), 2) for cls, count in counter.items()}\n\n\nclass_weights = get_class_weights(data['Financial Distress'].values)\nprint(class_weights)",
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": "{0: 1.0, 1: 26.0}\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class_weights={0:1.0,1:26.0}",
      "execution_count": 79,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "model = LogisticRegression(solver='liblinear',  class_weight=class_weights)\nmodel.fit(X_train, y_train)",
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 80,
          "data": {
            "text/plain": "LogisticRegression(C=1.0, class_weight={0: 1.0, 1: 26.0}, dual=False,\n          fit_intercept=True, intercept_scaling=1, max_iter=100,\n          multi_class='warn', n_jobs=None, penalty='l2', random_state=None,\n          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y_pred=model.predict(X_test)",
      "execution_count": 81,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "f1_score(y_test, y_pred, average='weighted')",
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 82,
          "data": {
            "text/plain": "0.23878764935780006"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "pd.DataFrame(confusion_matrix(y_test, y_pred))",
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 83,
          "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>0</th>\n      <th>1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>148</td>\n      <td>913</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0</td>\n      <td>41</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "     0    1\n0  148  913\n1    0   41"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "recall_score(y_test, y_pred)\n",
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 84,
          "data": {
            "text/plain": "1.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python36",
      "display_name": "Python 3.6",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.6",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}