Logistic_Regression_Binary.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import necessary libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "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>Time</th>\n",
       "      <th>V1</th>\n",
       "      <th>V2</th>\n",
       "      <th>V3</th>\n",
       "      <th>V4</th>\n",
       "      <th>V5</th>\n",
       "      <th>V6</th>\n",
       "      <th>V7</th>\n",
       "      <th>V8</th>\n",
       "      <th>V9</th>\n",
       "      <th>...</th>\n",
       "      <th>V21</th>\n",
       "      <th>V22</th>\n",
       "      <th>V23</th>\n",
       "      <th>V24</th>\n",
       "      <th>V25</th>\n",
       "      <th>V26</th>\n",
       "      <th>V27</th>\n",
       "      <th>V28</th>\n",
       "      <th>Amount</th>\n",
       "      <th>Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.359807</td>\n",
       "      <td>-0.072781</td>\n",
       "      <td>2.536347</td>\n",
       "      <td>1.378155</td>\n",
       "      <td>-0.338321</td>\n",
       "      <td>0.462388</td>\n",
       "      <td>0.239599</td>\n",
       "      <td>0.098698</td>\n",
       "      <td>0.363787</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.018307</td>\n",
       "      <td>0.277838</td>\n",
       "      <td>-0.110474</td>\n",
       "      <td>0.066928</td>\n",
       "      <td>0.128539</td>\n",
       "      <td>-0.189115</td>\n",
       "      <td>0.133558</td>\n",
       "      <td>-0.021053</td>\n",
       "      <td>149.62</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.191857</td>\n",
       "      <td>0.266151</td>\n",
       "      <td>0.166480</td>\n",
       "      <td>0.448154</td>\n",
       "      <td>0.060018</td>\n",
       "      <td>-0.082361</td>\n",
       "      <td>-0.078803</td>\n",
       "      <td>0.085102</td>\n",
       "      <td>-0.255425</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.225775</td>\n",
       "      <td>-0.638672</td>\n",
       "      <td>0.101288</td>\n",
       "      <td>-0.339846</td>\n",
       "      <td>0.167170</td>\n",
       "      <td>0.125895</td>\n",
       "      <td>-0.008983</td>\n",
       "      <td>0.014724</td>\n",
       "      <td>2.69</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>-1.358354</td>\n",
       "      <td>-1.340163</td>\n",
       "      <td>1.773209</td>\n",
       "      <td>0.379780</td>\n",
       "      <td>-0.503198</td>\n",
       "      <td>1.800499</td>\n",
       "      <td>0.791461</td>\n",
       "      <td>0.247676</td>\n",
       "      <td>-1.514654</td>\n",
       "      <td>...</td>\n",
       "      <td>0.247998</td>\n",
       "      <td>0.771679</td>\n",
       "      <td>0.909412</td>\n",
       "      <td>-0.689281</td>\n",
       "      <td>-0.327642</td>\n",
       "      <td>-0.139097</td>\n",
       "      <td>-0.055353</td>\n",
       "      <td>-0.059752</td>\n",
       "      <td>378.66</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>-0.966272</td>\n",
       "      <td>-0.185226</td>\n",
       "      <td>1.792993</td>\n",
       "      <td>-0.863291</td>\n",
       "      <td>-0.010309</td>\n",
       "      <td>1.247203</td>\n",
       "      <td>0.237609</td>\n",
       "      <td>0.377436</td>\n",
       "      <td>-1.387024</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.108300</td>\n",
       "      <td>0.005274</td>\n",
       "      <td>-0.190321</td>\n",
       "      <td>-1.175575</td>\n",
       "      <td>0.647376</td>\n",
       "      <td>-0.221929</td>\n",
       "      <td>0.062723</td>\n",
       "      <td>0.061458</td>\n",
       "      <td>123.50</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.0</td>\n",
       "      <td>-1.158233</td>\n",
       "      <td>0.877737</td>\n",
       "      <td>1.548718</td>\n",
       "      <td>0.403034</td>\n",
       "      <td>-0.407193</td>\n",
       "      <td>0.095921</td>\n",
       "      <td>0.592941</td>\n",
       "      <td>-0.270533</td>\n",
       "      <td>0.817739</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.009431</td>\n",
       "      <td>0.798278</td>\n",
       "      <td>-0.137458</td>\n",
       "      <td>0.141267</td>\n",
       "      <td>-0.206010</td>\n",
       "      <td>0.502292</td>\n",
       "      <td>0.219422</td>\n",
       "      <td>0.215153</td>\n",
       "      <td>69.99</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2.0</td>\n",
       "      <td>-0.425966</td>\n",
       "      <td>0.960523</td>\n",
       "      <td>1.141109</td>\n",
       "      <td>-0.168252</td>\n",
       "      <td>0.420987</td>\n",
       "      <td>-0.029728</td>\n",
       "      <td>0.476201</td>\n",
       "      <td>0.260314</td>\n",
       "      <td>-0.568671</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.208254</td>\n",
       "      <td>-0.559825</td>\n",
       "      <td>-0.026398</td>\n",
       "      <td>-0.371427</td>\n",
       "      <td>-0.232794</td>\n",
       "      <td>0.105915</td>\n",
       "      <td>0.253844</td>\n",
       "      <td>0.081080</td>\n",
       "      <td>3.67</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>4.0</td>\n",
       "      <td>1.229658</td>\n",
       "      <td>0.141004</td>\n",
       "      <td>0.045371</td>\n",
       "      <td>1.202613</td>\n",
       "      <td>0.191881</td>\n",
       "      <td>0.272708</td>\n",
       "      <td>-0.005159</td>\n",
       "      <td>0.081213</td>\n",
       "      <td>0.464960</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.167716</td>\n",
       "      <td>-0.270710</td>\n",
       "      <td>-0.154104</td>\n",
       "      <td>-0.780055</td>\n",
       "      <td>0.750137</td>\n",
       "      <td>-0.257237</td>\n",
       "      <td>0.034507</td>\n",
       "      <td>0.005168</td>\n",
       "      <td>4.99</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7.0</td>\n",
       "      <td>-0.644269</td>\n",
       "      <td>1.417964</td>\n",
       "      <td>1.074380</td>\n",
       "      <td>-0.492199</td>\n",
       "      <td>0.948934</td>\n",
       "      <td>0.428118</td>\n",
       "      <td>1.120631</td>\n",
       "      <td>-3.807864</td>\n",
       "      <td>0.615375</td>\n",
       "      <td>...</td>\n",
       "      <td>1.943465</td>\n",
       "      <td>-1.015455</td>\n",
       "      <td>0.057504</td>\n",
       "      <td>-0.649709</td>\n",
       "      <td>-0.415267</td>\n",
       "      <td>-0.051634</td>\n",
       "      <td>-1.206921</td>\n",
       "      <td>-1.085339</td>\n",
       "      <td>40.80</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>7.0</td>\n",
       "      <td>-0.894286</td>\n",
       "      <td>0.286157</td>\n",
       "      <td>-0.113192</td>\n",
       "      <td>-0.271526</td>\n",
       "      <td>2.669599</td>\n",
       "      <td>3.721818</td>\n",
       "      <td>0.370145</td>\n",
       "      <td>0.851084</td>\n",
       "      <td>-0.392048</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.073425</td>\n",
       "      <td>-0.268092</td>\n",
       "      <td>-0.204233</td>\n",
       "      <td>1.011592</td>\n",
       "      <td>0.373205</td>\n",
       "      <td>-0.384157</td>\n",
       "      <td>0.011747</td>\n",
       "      <td>0.142404</td>\n",
       "      <td>93.20</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>9.0</td>\n",
       "      <td>-0.338262</td>\n",
       "      <td>1.119593</td>\n",
       "      <td>1.044367</td>\n",
       "      <td>-0.222187</td>\n",
       "      <td>0.499361</td>\n",
       "      <td>-0.246761</td>\n",
       "      <td>0.651583</td>\n",
       "      <td>0.069539</td>\n",
       "      <td>-0.736727</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.246914</td>\n",
       "      <td>-0.633753</td>\n",
       "      <td>-0.120794</td>\n",
       "      <td>-0.385050</td>\n",
       "      <td>-0.069733</td>\n",
       "      <td>0.094199</td>\n",
       "      <td>0.246219</td>\n",
       "      <td>0.083076</td>\n",
       "      <td>3.68</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10 rows × 31 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Time        V1        V2        V3        V4        V5        V6        V7  \\\n",
       "0   0.0 -1.359807 -0.072781  2.536347  1.378155 -0.338321  0.462388  0.239599   \n",
       "1   0.0  1.191857  0.266151  0.166480  0.448154  0.060018 -0.082361 -0.078803   \n",
       "2   1.0 -1.358354 -1.340163  1.773209  0.379780 -0.503198  1.800499  0.791461   \n",
       "3   1.0 -0.966272 -0.185226  1.792993 -0.863291 -0.010309  1.247203  0.237609   \n",
       "4   2.0 -1.158233  0.877737  1.548718  0.403034 -0.407193  0.095921  0.592941   \n",
       "5   2.0 -0.425966  0.960523  1.141109 -0.168252  0.420987 -0.029728  0.476201   \n",
       "6   4.0  1.229658  0.141004  0.045371  1.202613  0.191881  0.272708 -0.005159   \n",
       "7   7.0 -0.644269  1.417964  1.074380 -0.492199  0.948934  0.428118  1.120631   \n",
       "8   7.0 -0.894286  0.286157 -0.113192 -0.271526  2.669599  3.721818  0.370145   \n",
       "9   9.0 -0.338262  1.119593  1.044367 -0.222187  0.499361 -0.246761  0.651583   \n",
       "\n",
       "         V8        V9  ...       V21       V22       V23       V24       V25  \\\n",
       "0  0.098698  0.363787  ... -0.018307  0.277838 -0.110474  0.066928  0.128539   \n",
       "1  0.085102 -0.255425  ... -0.225775 -0.638672  0.101288 -0.339846  0.167170   \n",
       "2  0.247676 -1.514654  ...  0.247998  0.771679  0.909412 -0.689281 -0.327642   \n",
       "3  0.377436 -1.387024  ... -0.108300  0.005274 -0.190321 -1.175575  0.647376   \n",
       "4 -0.270533  0.817739  ... -0.009431  0.798278 -0.137458  0.141267 -0.206010   \n",
       "5  0.260314 -0.568671  ... -0.208254 -0.559825 -0.026398 -0.371427 -0.232794   \n",
       "6  0.081213  0.464960  ... -0.167716 -0.270710 -0.154104 -0.780055  0.750137   \n",
       "7 -3.807864  0.615375  ...  1.943465 -1.015455  0.057504 -0.649709 -0.415267   \n",
       "8  0.851084 -0.392048  ... -0.073425 -0.268092 -0.204233  1.011592  0.373205   \n",
       "9  0.069539 -0.736727  ... -0.246914 -0.633753 -0.120794 -0.385050 -0.069733   \n",
       "\n",
       "        V26       V27       V28  Amount  Class  \n",
       "0 -0.189115  0.133558 -0.021053  149.62      0  \n",
       "1  0.125895 -0.008983  0.014724    2.69      0  \n",
       "2 -0.139097 -0.055353 -0.059752  378.66      0  \n",
       "3 -0.221929  0.062723  0.061458  123.50      0  \n",
       "4  0.502292  0.219422  0.215153   69.99      0  \n",
       "5  0.105915  0.253844  0.081080    3.67      0  \n",
       "6 -0.257237  0.034507  0.005168    4.99      0  \n",
       "7 -0.051634 -1.206921 -1.085339   40.80      0  \n",
       "8 -0.384157  0.011747  0.142404   93.20      0  \n",
       "9  0.094199  0.246219  0.083076    3.68      0  \n",
       "\n",
       "[10 rows x 31 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load credit card fraud data\n",
    "transactions_df = pd.read_csv(\"data/creditcard.csv\", header=0)\n",
    "transactions_df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set()\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "transactions_df.dropna()\n",
    "\n",
    "FRAUDULENT_CLASS   = 1\n",
    "NUMBER_OF_CLASSES  = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the percentage of each of data for each class\n",
    "def fraudulent_percentage(transactions_df):\n",
    "    global FRAUDULENT_CLASS\n",
    "    \n",
    "    total_data_length = transactions_df.shape[0]\n",
    "    fraudulent_data = transactions_df[transactions_df['Class']==FRAUDULENT_CLASS]\n",
    "    fraudulent_data_length = fraudulent_data.shape[0]\n",
    "    fraudulent_data_percent = fraudulent_data_length/total_data_length\n",
    "    \n",
    "    ## print stats\n",
    "    print(\"total_data_length: \", total_data_length)\n",
    "    print(\"fraudulent_data_length: \", fraudulent_data_length)\n",
    "    print(\"fraudulent_percentage: \", fraudulent_data_percent)\n",
    "    \n",
    "    return fraudulent_data_percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total_data_length:  284807\n",
      "fraudulent_data_length:  492\n",
      "fraudulent_percentage:  0.001727485630620034\n"
     ]
    }
   ],
   "source": [
    "fraudulent_transactions_percent = fraudulent_percentage(transactions_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## now split the data into training and test data bins\n",
    "def train_test_split(transaction_df, train_frac= 0.7, seed=1):\n",
    "    \n",
    "    # seed for repeatability\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    transaction_matrix = transaction_df.as_matrix()\n",
    "    np.random.shuffle(transaction_matrix)\n",
    "    \n",
    "    data_len = transaction_df.shape[0]\n",
    "    train_data_len = int(train_frac*transaction_df.shape[0])\n",
    "    \n",
    "    # shuffle and split the data\n",
    "    train_features = transaction_matrix[0:train_data_len, 0:transaction_df.shape[1]-2]\n",
    "    train_labels   = transaction_matrix[0:train_data_len, transaction_df.shape[1]-1]\n",
    "    test_features  = transaction_matrix[train_data_len:data_len, 0:transaction_df.shape[1]-2]\n",
    "    test_labels    = transaction_matrix[train_data_len:data_len,  transaction_df.shape[1]-1]\n",
    "    \n",
    "    return (train_features, train_labels), (test_features, test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  import sys\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_data_length:  199364\n",
      "test_data_length:  85443\n",
      "total_data_length:  284807\n",
      "\n",
      "Test passed\n",
      "\n",
      "(199364, 29)\n",
      "(199364,)\n"
     ]
    }
   ],
   "source": [
    "(train_features, train_labels), (test_features, test_labels) = train_test_split(transactions_df)\n",
    "\n",
    "print(\"train_data_length: \", train_features.shape[0])\n",
    "print(\"test_data_length: \", test_features.shape[0])\n",
    "print(\"total_data_length: \", transactions_df.shape[0])\n",
    "try:\n",
    "    assert(transactions_df.shape[0]== (train_features.shape[0] + test_features.shape[0]))\n",
    "    print(\"\\nTest passed\\n\")\n",
    "except Exception as ex:\n",
    "    print(\"total data length is not the same\")\n",
    "\n",
    "print(train_features.shape)\n",
    "print(train_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper functions to evaluate metrics\n",
    "def evaluate(test_features, test_labels, estimated_params, verbose=True):\n",
    "    \n",
    "    test_preds = fit_model(test_features, estimated_params[0], estimated_params[1]).reshape(test_labels.shape)\n",
    "    \n",
    "    # calculate true positives, false positives, true negatives, false negatives\n",
    "    tp = np.logical_and(test_labels, test_preds).sum()\n",
    "    fp = np.logical_and(1-test_labels, test_preds).sum()\n",
    "    tn = np.logical_and(1-test_labels, 1-test_preds).sum()\n",
    "    fn = np.logical_and(test_labels, 1-test_preds).sum()\n",
    "\n",
    "    # calculate binary classification metrics\n",
    "    recall    = tp / (tp + fn)\n",
    "    precision = tp / (tp + fp)\n",
    "    accuracy  = (tp + tn) / (tp + fp + tn + fn)\n",
    "    f1_score  = 2.0*recall*precision/(recall + precision)\n",
    "    \n",
    "    if (verbose == True):\n",
    "        # printing a table of metrics\n",
    "        print(\"\\n{:<11} {:.3f}\".format('Recall:', recall))\n",
    "        print(\"{:<11} {:.3f}\".format('Precision:', precision))\n",
    "        print(\"{:<11} {:.3f}\".format('Accuracy:', accuracy))\n",
    "    \n",
    "    confusion_matrix = pd.crosstab(test_labels, test_preds, rownames=['actual (row)'], colnames=['prediction (col)'])\n",
    "    \n",
    "    return {'TP': tp, 'FP': fp, 'FN': fn, 'TN': tn, \n",
    "            'Precision': precision, 'Recall': recall, 'Accuracy': accuracy, 'F1_Score': f1_score, \n",
    "            'confusion_matrix': confusion_matrix}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Classifer\n",
    "A linear classifier tries to fit a hyperplane across N-dimensions to split the data into two categories.  \n",
    "To do this we need to define an objective function and estimate parameters in that objective function.  \n",
    "As we are trying to fit a linear hyperplane in N-dimensions, we can a linear model of type,  \n",
    "$$ f(X, W, b) = WX + b $$\n",
    "So, the objective function now becomes,\n",
    "$$  min \\space J(W,b) = \\frac{1}{2N}\\sum_{i=1}^{N} \\left(f(X, W, b) - Y \\right)^2 $$\n",
    "where,  \n",
    "> $K$, is the number of class categories  \n",
    "> $N$, is the training/learning data length.  \n",
    "> $D$, is the number of features in a given data point\n",
    "\n",
    "A Steepest descent algorithm can be used to estimate parameters, $ W, b $.\n",
    "  \n",
    "Unlike linear regression which outputs continuous values for prediction, a logistic regression transforms its output using the logistic sigmoid/logistic function to return a probability value which can be mapped to 2 or more discrete classes.   \n",
    "  \n",
    "The function, $ f(X, W, b) $, outputs/predicts probabilities of each class. So, in-order to convert this probability to a binary class, we can use a Sigmoid or soft-max function.  \n",
    "A Sigmoid function is logistic function that transforms any real-value into a space $ \\left[0, 1.0\\right] $. \n",
    "$$ \\sigma(X) = \\frac{1.0}{1.0+\\exp(-X)} $$  \n",
    "A tipping point can be used, where values greater than tipping point can be positive class and values less than tipping point can be a negative class.  \n",
    "  \n",
    "For multi-class problem, a Softmax(normalized exponential) function can be used and usually the class with higher-probability wins. A Softmax function takes an input vector of $K$ real-numbers and normalizes it into a probability distribution consisting of K probabilities proportional to the exponentials of the input numbers.  \n",
    "$$ \\sigma(Z_i) = \\frac{\\exp(Z_i)}{\\sum_{j=1}^{K}\\exp(Z_j)}$$  \n",
    "  \n",
    "Binary logistic regression, multinomial logistic regression, ordinal logistic regression (deals with dependent variables that are ordered).  \n",
    "\n",
    "By using high-order polynomial terms, we can get even more complex decision boundaries.\n",
    "\n",
    "## Non-Convex function\n",
    "Mean-Squared Error is a good cost function for linear regression. But when it comes to logistic regression, because of the sigmoid function, this MSE cost function becomes non-linear and in-turn will be non-convex function. Which means many local minimas exist. This could or could not work and the numerical optimizer might get stuck in one of the local minimas.  \n",
    "To deal with this, the cost function can be organized as, \n",
    "\\begin{eqnarray}\n",
    "Cost (X, W, b, Y) &=& -\\log(f(X,W,b), \\space \\text{if} \\space Y=1 \\\\\n",
    "                  &=& -\\log(1-f(X,W,b)), \\space \\text{if} \\space Y=0\n",
    "\\end{eqnarray}\n",
    "\n",
    "This means, when we predict right, the cost will be 0 and if we predict wrong the cost will slowly increase to infinity, penalizing the system. Inverted for the other class to get the same behavior. So, the final cost function can be written as (for binary classification) , \n",
    "$$ J(X,W,b,Y) = -Y\\log(f(X,W,b)) - (1-Y)\\log(1-f(X,W,b)) $$\n",
    "This can be interpreted as if Y is 0, first term gets neglected. If Y is 1, then second-term gets neglected.  \n",
    "In vector form,\n",
    "$$ min \\space J(X,W,b,Y) = \\frac{-1}{2N}\\left[Y^T\\log(f(X,W,b)) + (1-Y)^T\\log(1-f(X,W,b))\\right]$$\n",
    "\n",
    "The above representation is also called as cross-entropy cost function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid_func(X):\n",
    "    sigmoid_X = 1.0 / (1.0 + np.exp(-X))\n",
    "    return sigmoid_X\n",
    "\n",
    "def apply_decision_boundary(X):\n",
    "    return np.where(X > 0.5, 1, 0)\n",
    "\n",
    "def fit_model(data, weights, bias):\n",
    "    \n",
    "    # model we are fitting is, W*X^T + b\n",
    "    WX = np.matmul(weights, data.T)\n",
    "    \n",
    "    WX_b = WX\n",
    "    for class_idx in range(0, bias.shape[0]):\n",
    "        WX_b[class_idx, :] = WX_b[class_idx, :] + bias[class_idx]\n",
    "    \n",
    "    # apply sigmoid function.\n",
    "    # as the predicted values will be probability, applying sigmoid value will translate into 0, 1\n",
    "    WX_b = sigmoid_func(WX_b)\n",
    "    WX_b = apply_decision_boundary(WX_b)\n",
    "    \n",
    "    return WX_b\n",
    "\n",
    "def fit_model_with_prob(data, weights, bias):\n",
    "    \n",
    "    # model we are fitting is, W*X^T + b\n",
    "    WX = np.matmul(weights, data.T)\n",
    "    \n",
    "    WX_b = WX\n",
    "    for class_idx in range(0, bias.shape[0]):\n",
    "        WX_b[class_idx, :] = WX_b[class_idx, :] + bias[class_idx]\n",
    "    \n",
    "    # apply sigmoid function.\n",
    "    # as the predicted values will be probability, applying sigmoid value will translate into range 0, 1\n",
    "    WX_b = sigmoid_func(WX_b)\n",
    "    \n",
    "    return WX_b\n",
    "\n",
    "# cost function based on Mean-Squared Error with sigmoid prediction function\n",
    "def cost_function_MSE(data, decision_vars, class_labels, class_weight=None):\n",
    "    # data: size (N x D)\n",
    "    # decision_vars: size (K x D)\n",
    "    # class_labels: size (K x N)\n",
    "    \n",
    "    model_val = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    error = np.subtract(model_val, class_labels)\n",
    "    \n",
    "    error_sq = np.power(error, 2.0)\n",
    "    error_sq_mean = np.mean(error_sq)\n",
    "    return error_sq_mean/2.0\n",
    "\n",
    "# gradient of the cost function w.r.to decision variables, weights & bias, by substituting sigmoid function into \n",
    "# J. Note that because of the derivative of the sigmoid function being present in the gradient, this will affect our\n",
    "# algorithm convergence. As sigmoid function is a very smooth and almost saturates at 0, 1.\n",
    "def model_gradient_MSE(data, decision_vars, class_labels, class_weight=None):\n",
    "    gradient  = np.empty((2,1), dtype=object)\n",
    "    data_len  = data.shape[0]\n",
    "    \n",
    "    model_val = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    error     = np.subtract(model_val, class_labels)\n",
    "    error_X   = np.matmul(error, data)\n",
    "    \n",
    "    # calculate gradient of the sigmoid function\n",
    "    sigmoid_val = fit_model_with_prob(data, decision_vars[0], decision_vars[1])\n",
    "    sigmoid_gradient = np.dot(sigmoid_val, (1 - sigmoid_val).transpose())\n",
    "    \n",
    "    # dJ/dW\n",
    "    gradient[0][0] = error_X * sigmoid_gradient /data_len\n",
    "    \n",
    "    # dJ/db\n",
    "    # as this error term will be the same, just take one of them\n",
    "    gradient[1][0] = np.array(np.mean(error * sigmoid_gradient))\n",
    "    \n",
    "    return gradient\n",
    "\n",
    "def cost_function_CrossEntropy(data, decision_vars, class_labels, class_weight=None):\n",
    "    # data: size (N x D)\n",
    "    # decision_vars: size (K x D)\n",
    "    # class_labels: size (K x N)\n",
    "    \n",
    "    predicted_class = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    \n",
    "    # work around, instead of supplying 0 to log, supply some small value so as to get the desired affect in the cost\n",
    "    predicted_class = np.where(predicted_class < 1e-5, 1e-8, predicted_class)\n",
    "    \n",
    "    predicted_neg_class = 1.0 - predicted_class\n",
    "    predicted_neg_class = np.where(predicted_neg_class < 1e-5, 1e-8, predicted_neg_class)\n",
    "    \n",
    "    log_prediction_pos_class = np.log(predicted_class)\n",
    "    log_prediction_neg_class = np.log(predicted_neg_class)\n",
    "    \n",
    "    desired_neg_class = np.subtract(1, class_labels)\n",
    "    desired_pos_class = class_labels\n",
    "    \n",
    "    cross_entropy =  np.dot(log_prediction_pos_class, desired_pos_class) \\\n",
    "                   + np.dot(log_prediction_neg_class, desired_neg_class)\n",
    "      \n",
    "    cross_entropy_mean = -cross_entropy/data.shape[0]\n",
    "    return cross_entropy_mean\n",
    "\n",
    "def model_gradient_CrossEntropy(data, decision_vars, class_labels, class_weight=None):\n",
    "    gradient  = np.empty((2,1), dtype=object)\n",
    "    data_len  = data.shape[0]\n",
    "    \n",
    "    model_val = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    error     = np.subtract(model_val, class_labels)\n",
    "    error_X   = np.matmul(error, data)\n",
    "    \n",
    "    # dJ/dW\n",
    "    gradient[0][0] = error_X/data_len\n",
    "    \n",
    "    # dJ/db\n",
    "    # as this error term will be the same, just take one of them\n",
    "    gradient[1][0] = np.array(np.mean(error))\n",
    "    \n",
    "    return gradient\n",
    "\n",
    "def generate_batch_indices(data_len, batch_size=100):   \n",
    "    shuffle_indexing = np.random.permutation(data_len)\n",
    "    n_batches        = int(data_len / batch_size)\n",
    "    \n",
    "    total_batch_len = n_batches*batch_size\n",
    "    left_over_data  = data_len - total_batch_len\n",
    "    \n",
    "    batch_indices   = [None]*n_batches\n",
    "    for batch_iter in range(0, n_batches):\n",
    "        batch_indices[batch_iter] = shuffle_indexing[batch_iter*batch_size : (batch_iter+1)*batch_size]\n",
    "    \n",
    "    if (left_over_data > 0):\n",
    "        batch_indices.append(shuffle_indexing[total_batch_len : data_len])\n",
    "    \n",
    "    return batch_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def steepest_descent(data, class_labels, initial_conditions,\n",
    "                     cost_func, cost_func_gradient, \n",
    "                     n_iter=10, \n",
    "                     step_size=0.8, \n",
    "                     batch_size=500,\n",
    "                     class_weight=None,\n",
    "                     stopping_tol=1e-3):\n",
    "    \n",
    "    estimated_params = initial_conditions\n",
    "    cost_func_trend  = [None]*(n_iter+1)\n",
    "    \n",
    "    total_cost = cost_func(data, estimated_params, class_labels, class_weight)\n",
    "    cost_func_trend[0] = total_cost\n",
    "    \n",
    "    error = total_cost\n",
    "    \n",
    "    for iteration in range(0, n_iter):\n",
    "        if (error > stopping_tol):\n",
    "            batch_indices_list = generate_batch_indices(data.shape[0], batch_size)\n",
    "\n",
    "            for batch_indices in batch_indices_list:\n",
    "                train_data   = data[batch_indices, :]\n",
    "                train_labels = class_labels[batch_indices]\n",
    "\n",
    "                gradient = cost_func_gradient(train_data, estimated_params, train_labels, class_weight)\n",
    "\n",
    "                # update Weights\n",
    "                estimated_params[0] = np.add(estimated_params[0], -step_size*gradient[0][0])\n",
    "\n",
    "                # update bias\n",
    "                estimated_params[1] = np.add(estimated_params[1], -step_size*gradient[1][0])\n",
    "\n",
    "            total_cost = cost_func(data, estimated_params, class_labels, class_weight)\n",
    "\n",
    "            cost_func_trend[iteration+1] = total_cost\n",
    "            error = np.abs(total_cost - error)\n",
    "    \n",
    "    return estimated_params, cost_func_trend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare estimation of parameters based on MSE cost (non-Convex) and cross-entropy cost (Convex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## scale full data to be in the range 0 to 1\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "scaler = MinMaxScaler()\n",
    "scaler.fit(train_features)\n",
    "train_features_scaled = scaler.transform(train_features)\n",
    "scaler.fit(test_features)\n",
    "test_features_scaled  = scaler.transform(test_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# start with small sample size to test out the implementation\n",
    "sample_size = train_features.shape[0]\n",
    "NUMBER_OF_FEATURES = 28\n",
    "\n",
    "initial_weights = 0.1*np.ones((1, NUMBER_OF_FEATURES))\n",
    "initial_bias    = np.array([0.5])\n",
    "\n",
    "# First do estimation based on the Mean-Squared Error\n",
    "estimated_params_MSE, obj_fun_trend_MSE = steepest_descent(train_features[0:sample_size, 1:], \n",
    "                                                           train_labels[0:sample_size], \n",
    "                                                           [initial_weights, initial_bias], \n",
    "                                                           cost_function_MSE,\n",
    "                                                           model_gradient_MSE, \n",
    "                                                           n_iter=300,\n",
    "                                                           step_size=0.35,\n",
    "                                                           batch_size=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# second do estimation based on the Cross-Entropy cost function\n",
    "estimated_params_CE, obj_fun_trend_CE = steepest_descent(train_features[0:sample_size, 1:], \n",
    "                                                        train_labels[0:sample_size], \n",
    "                                                        [initial_weights, initial_bias],\n",
    "                                                        cost_function_CrossEntropy,\n",
    "                                                        model_gradient_CrossEntropy, \n",
    "                                                        n_iter=300,\n",
    "                                                        step_size=0.45,\n",
    "                                                        batch_size=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean-Squred-Metric ---------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 106,\n",
       " 'FP': 17,\n",
       " 'FN': 35,\n",
       " 'TN': 85285,\n",
       " 'Precision': 0.8617886178861789,\n",
       " 'Recall': 0.75177304964539,\n",
       " 'Accuracy': 0.9993914071369217,\n",
       " 'F1_Score': 0.803030303030303,\n",
       " 'confusion_matrix': prediction (col)      0    1\n",
       " actual (row)                \n",
       " 0.0               85285   17\n",
       " 1.0                  35  106}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-Entrop-Metric --------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 48,\n",
       " 'FP': 5,\n",
       " 'FN': 93,\n",
       " 'TN': 85297,\n",
       " 'Precision': 0.9056603773584906,\n",
       " 'Recall': 0.3404255319148936,\n",
       " 'Accuracy': 0.9988530365272755,\n",
       " 'F1_Score': 0.4948453608247423,\n",
       " 'confusion_matrix': prediction (col)      0   1\n",
       " actual (row)               \n",
       " 0.0               85297   5\n",
       " 1.0                  93  48}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated-Params -----------\n"
     ]
    },
    {
     "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>W_0</th>\n",
       "      <th>W_1</th>\n",
       "      <th>W_2</th>\n",
       "      <th>W_3</th>\n",
       "      <th>W_4</th>\n",
       "      <th>W_5</th>\n",
       "      <th>W_6</th>\n",
       "      <th>W_7</th>\n",
       "      <th>W_8</th>\n",
       "      <th>W_9</th>\n",
       "      <th>...</th>\n",
       "      <th>W_19</th>\n",
       "      <th>W_20</th>\n",
       "      <th>W_21</th>\n",
       "      <th>W_22</th>\n",
       "      <th>W_23</th>\n",
       "      <th>W_24</th>\n",
       "      <th>W_25</th>\n",
       "      <th>W_26</th>\n",
       "      <th>W_27</th>\n",
       "      <th>bias</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>initial</th>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>estimated_MSE</th>\n",
       "      <td>0.168321</td>\n",
       "      <td>-1.422726</td>\n",
       "      <td>-1.114376</td>\n",
       "      <td>-2.286385</td>\n",
       "      <td>-0.963065</td>\n",
       "      <td>0.819401</td>\n",
       "      <td>-1.848582</td>\n",
       "      <td>-0.102343</td>\n",
       "      <td>-2.133800</td>\n",
       "      <td>-0.771617</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.038901</td>\n",
       "      <td>0.248492</td>\n",
       "      <td>0.734833</td>\n",
       "      <td>0.432432</td>\n",
       "      <td>0.901212</td>\n",
       "      <td>-0.261955</td>\n",
       "      <td>-1.295701</td>\n",
       "      <td>-0.438895</td>\n",
       "      <td>0.200878</td>\n",
       "      <td>-34.664437</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>estimated_CrossEntropy</th>\n",
       "      <td>0.053101</td>\n",
       "      <td>-0.011622</td>\n",
       "      <td>0.028935</td>\n",
       "      <td>0.023983</td>\n",
       "      <td>0.006728</td>\n",
       "      <td>0.001555</td>\n",
       "      <td>0.022638</td>\n",
       "      <td>0.009060</td>\n",
       "      <td>-0.004637</td>\n",
       "      <td>-0.040632</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.033610</td>\n",
       "      <td>0.032075</td>\n",
       "      <td>0.020443</td>\n",
       "      <td>-0.014262</td>\n",
       "      <td>0.020120</td>\n",
       "      <td>-0.000787</td>\n",
       "      <td>0.007954</td>\n",
       "      <td>-0.038425</td>\n",
       "      <td>-0.005134</td>\n",
       "      <td>-0.250373</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3 rows × 29 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                             W_0       W_1       W_2       W_3       W_4  \\\n",
       "initial                 0.100000  0.100000  0.100000  0.100000  0.100000   \n",
       "estimated_MSE           0.168321 -1.422726 -1.114376 -2.286385 -0.963065   \n",
       "estimated_CrossEntropy  0.053101 -0.011622  0.028935  0.023983  0.006728   \n",
       "\n",
       "                             W_5       W_6       W_7       W_8       W_9  ...  \\\n",
       "initial                 0.100000  0.100000  0.100000  0.100000  0.100000  ...   \n",
       "estimated_MSE           0.819401 -1.848582 -0.102343 -2.133800 -0.771617  ...   \n",
       "estimated_CrossEntropy  0.001555  0.022638  0.009060 -0.004637 -0.040632  ...   \n",
       "\n",
       "                            W_19      W_20      W_21      W_22      W_23  \\\n",
       "initial                 0.100000  0.100000  0.100000  0.100000  0.100000   \n",
       "estimated_MSE          -0.038901  0.248492  0.734833  0.432432  0.901212   \n",
       "estimated_CrossEntropy -0.033610  0.032075  0.020443 -0.014262  0.020120   \n",
       "\n",
       "                            W_24      W_25      W_26      W_27       bias  \n",
       "initial                 0.100000  0.100000  0.100000  0.100000   0.500000  \n",
       "estimated_MSE          -0.261955 -1.295701 -0.438895  0.200878 -34.664437  \n",
       "estimated_CrossEntropy -0.000787  0.007954 -0.038425 -0.005134  -0.250373  \n",
       "\n",
       "[3 rows x 29 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# combine results together \n",
    "estimated_params = pd.DataFrame()\n",
    "estimated_params['initial']                = np.append(initial_weights, initial_bias)\n",
    "estimated_params['estimated_MSE']          = np.append(estimated_params_MSE[0], estimated_params_MSE[1])\n",
    "estimated_params['estimated_CrossEntropy'] = np.append(estimated_params_CE[0], estimated_params_CE[1])\n",
    "estimated_params = estimated_params.T\n",
    "estimated_params.index = ['initial', 'estimated_MSE', 'estimated_CrossEntropy']\n",
    "estimated_params.columns = ['W_'+str(feature) for feature in range(0, NUMBER_OF_FEATURES)] + ['bias']\n",
    "\n",
    "# evaluate results \n",
    "evaluated_result_MSE = evaluate(test_features[:, 1:], test_labels, estimated_params_MSE, False)\n",
    "evaluated_result_CE  = evaluate(test_features[:, 1:], test_labels, estimated_params_CE, False)\n",
    "\n",
    "# plot trend of objective function\n",
    "plt.figure(figsize=(12,7))\n",
    "plt.plot(obj_fun_trend_MSE, 'r-o', markersize=3, linewidth=2)\n",
    "plt.plot(obj_fun_trend_CE, 'b-x', markersize=3, linewidth=2)\n",
    "plt.xlabel('iterations', fontsize=14)\n",
    "plt.ylabel('Objective function', fontsize=14)\n",
    "plt.legend(['Mean-Squared-Error', 'CrossEntropy'])\n",
    "plt.title(\"cost function trend for every iteration cycle\", fontsize=14)\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "# print metrics\n",
    "print(\"Mean-Squred-Metric ---------\")\n",
    "display(evaluated_result_MSE)\n",
    "\n",
    "print(\"Cross-Entrop-Metric --------\")\n",
    "display(evaluated_result_CE)\n",
    "\n",
    "print(\"Estimated-Params -----------\")\n",
    "display(estimated_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling class imbalance\n",
    "In this current dataset, the positive class (Fraudulent class) only accounts for 0.17% of the whole data. So, to improve Recall rate, we need to give our model sufficient amount of data belonging to Fraudulent class. There are multiple ways to deal with this.\n",
    "* **Up-Sampling Minority class**\n",
    " - We randomly at uniform sample existing minority class data and append to the existing data. This way, the model will be able to see the fraudulent/minority class data more-often than before.\n",
    "* **Down-Sampling Majority class**\n",
    " - We randomly at uniform sample down existing majority class data.\n",
    "* **Penalize algorithm/Class weights (Cost-Sensitive Training)**\n",
    " - We penalize more when our algorithm does bad for minority class interms of cost function which will increase the error and the model will be able to estimate properly\n",
    "* **Data Augmentation**\n",
    " - We can also augment data by deterministic noise upto to extent (based on the data) and feed it to the model\n",
    "\n",
    "  \n",
    "The cost function now becomes, \n",
    "$$ min \\space J(X,W,b,Y) = \\frac{-1}{N}\\left[W_1 Y^T\\log(\\sigma(Z)) + W_0 (1-Y)^T\\log(1-\\sigma(Z))\\right] $$\n",
    "where, \n",
    "> $W_0$ and $W_1$, are the weights for the class negative and positive respectively  \n",
    "> $\\sigma(Z)$, is the sigmoid function and $Z = f(X,W,b)$\n",
    "\n",
    "The gradient now becomes,\n",
    "\\begin{eqnarray}\n",
    "\\frac{\\partial J}{\\partial W} &=& \\frac{1}{N}\\sum\\left[\\left(W_0 \\sigma(Z) - W_1 Y\\right) - \\left(W_0 - W_1\\right)Y\\sigma(Z) \\right]X^T\\\\\n",
    "\\frac{\\partial J}{\\partial b} &=& \\frac{1}{N}\\sum\\left[\\left(W_0 \\sigma(Z) - W_1 Y\\right) - \\left(W_0 - W_1\\right)Y\\sigma(Z) \\right]\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_function_CrossEntropy_weighted(data, decision_vars, class_labels, class_weight=None):\n",
    "    # data: size (N x D)\n",
    "    # decision_vars: size (K x D)\n",
    "    # class_labels: size (K x N)\n",
    "    \n",
    "    pos_weight = 1.0\n",
    "    neg_weight = 1.0\n",
    "    if (class_weight != None):\n",
    "        neg_weight = class_weight[0]\n",
    "        pos_weight = class_weight[1]\n",
    "    \n",
    "    predicted_class = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    \n",
    "    # work around, instead of supplying 0 to log, supply some small value so as to get the desired affect in the cost\n",
    "    predicted_class = np.where(predicted_class < 1e-5, 1e-8, predicted_class)\n",
    "    \n",
    "    predicted_neg_class = 1.0 - predicted_class\n",
    "    predicted_neg_class = np.where(predicted_neg_class < 1e-5, 1e-8, predicted_neg_class)\n",
    "    \n",
    "    log_prediction_pos_class = np.log(predicted_class)\n",
    "    log_prediction_neg_class = np.log(predicted_neg_class)\n",
    "    \n",
    "    desired_neg_class = neg_weight*np.subtract(1, class_labels)\n",
    "    desired_pos_class = pos_weight*class_labels\n",
    "    \n",
    "    cross_entropy =  np.dot(log_prediction_pos_class, desired_pos_class) \\\n",
    "                   + np.dot(log_prediction_neg_class, desired_neg_class)\n",
    "      \n",
    "    cross_entropy_mean = -cross_entropy/data.shape[0]\n",
    "    return cross_entropy_mean\n",
    "\n",
    "def model_gradient_CrossEntropy_weighted(data, decision_vars, class_labels, class_weight=None):\n",
    "    gradient  = np.empty((2,1), dtype=object)\n",
    "    data_len  = data.shape[0]\n",
    "    \n",
    "    pos_weight = 1.0\n",
    "    neg_weight = 1.0\n",
    "    if (class_weight != None):\n",
    "        neg_weight = class_weight[0]\n",
    "        pos_weight = class_weight[1]\n",
    "    \n",
    "    weight_diff = neg_weight - pos_weight   \n",
    "    \n",
    "    model_val = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    \n",
    "    model_val_weighted   = neg_weight*model_val\n",
    "    class_label_weighted = pos_weight*class_labels\n",
    "    error                = np.subtract(model_val_weighted, class_label_weighted)\n",
    "    \n",
    "    if ((weight_diff > 1e-3) or (weight_diff < -1e-3)):\n",
    "        subtractive_term = np.multiply(model_val, class_labels)\n",
    "        subtractive_term = weight_diff*subtractive_term\n",
    "        error = np.subtract(error, subtractive_term)\n",
    "    \n",
    "    error_X   = np.matmul(error, data)\n",
    "    \n",
    "    # dJ/dW\n",
    "    gradient[0][0] = error_X/data_len\n",
    "    \n",
    "    # dJ/db\n",
    "    # as this error term will be the same, just take one of them\n",
    "    gradient[1][0] = np.array(np.mean(error))\n",
    "    \n",
    "    return gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's say the goal is to be able to classify 85% of the Fraudulent transactions correct\n",
    "\n",
    "# Using class weights we can penalize cost function whenever the data classifies fraudulent transactions wrong\n",
    "# in this example POSITIVE: FRAUDULENT, NEGATIVE: CLEAN_TRANSACTION\n",
    "# For Binary classification, negative class weight is fixed at 1, as it is 0\n",
    "class_weights = [1, 25] # [negative, positive]\n",
    "\n",
    "estimated_params_CE_wgt, obj_fun_trend_CE_wgt = steepest_descent(train_features[0:sample_size, 1:], \n",
    "                                                                 train_labels[0:sample_size], \n",
    "                                                                 [initial_weights, initial_bias], \n",
    "                                                                 cost_function_CrossEntropy_weighted,\n",
    "                                                                 model_gradient_CrossEntropy_weighted, \n",
    "                                                                 n_iter=350,\n",
    "                                                                 step_size=0.45,\n",
    "                                                                 batch_size=500,\n",
    "                                                                 class_weight=class_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-Entropy-UnWeighted --------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 48,\n",
       " 'FP': 5,\n",
       " 'FN': 93,\n",
       " 'TN': 85297,\n",
       " 'Precision': 0.9056603773584906,\n",
       " 'Recall': 0.3404255319148936,\n",
       " 'Accuracy': 0.9988530365272755,\n",
       " 'F1_Score': 0.4948453608247423,\n",
       " 'confusion_matrix': prediction (col)      0   1\n",
       " actual (row)               \n",
       " 0.0               85297   5\n",
       " 1.0                  93  48}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-Entropy-Weighted ----------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 117,\n",
       " 'FP': 165,\n",
       " 'FN': 24,\n",
       " 'TN': 85137,\n",
       " 'Precision': 0.4148936170212766,\n",
       " 'Recall': 0.8297872340425532,\n",
       " 'Accuracy': 0.9977879990168884,\n",
       " 'F1_Score': 0.553191489361702,\n",
       " 'confusion_matrix': prediction (col)      0    1\n",
       " actual (row)                \n",
       " 0.0               85137  165\n",
       " 1.0                  24  117}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluated_result_CE     = evaluate(test_features[:, 1:], test_labels, estimated_params_CE, False)\n",
    "evaluated_result_CE_wgt = evaluate(test_features[:, 1:], test_labels, estimated_params_CE_wgt, False)\n",
    "\n",
    "print(\"Cross-Entropy-UnWeighted --------\")\n",
    "display(evaluated_result_CE)\n",
    "\n",
    "print(\"Cross-Entropy-Weighted ----------\")\n",
    "display(evaluated_result_CE_wgt)\n",
    "\n",
    "# plot trend of objective function\n",
    "plt.figure(figsize=(12,7))\n",
    "plt.plot(obj_fun_trend_CE_wgt, 'r-o', markersize=3, linewidth=2)\n",
    "plt.xlabel('iterations', fontsize=14)\n",
    "plt.ylabel('Objective function', fontsize=14)\n",
    "plt.title(\"class weighted cost function trend for every iteration cycle\", fontsize=14)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using SkLearn \n",
    "from sklearn.linear_model import LogisticRegression\n",
    "binary_classifier_sk = LogisticRegression(solver='lbfgs', max_iter=250, multi_class='ovr', class_weight={0: 1, 1: 25})\n",
    "binary_classifier_sk.fit(train_features[0:sample_size, 1:], train_labels[0:sample_size])\n",
    "predicted_labels_sk = binary_classifier_sk.predict(test_features[:, 1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-Entropy-Weighted --------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 117,\n",
       " 'FP': 165,\n",
       " 'FN': 24,\n",
       " 'TN': 85137,\n",
       " 'Precision': 0.4148936170212766,\n",
       " 'Recall': 0.8297872340425532,\n",
       " 'Accuracy': 0.9977879990168884,\n",
       " 'F1_Score': 0.553191489361702,\n",
       " 'confusion_matrix': prediction (col)      0    1\n",
       " actual (row)                \n",
       " 0.0               85137  165\n",
       " 1.0                  24  117}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SkLearn based Binary Classification\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'recall': 0.8439716312056738,\n",
       " 'precision': 0.6134020618556701,\n",
       " 'accuracy': 0.9988647402361809,\n",
       " 'f1_score': 0.7104477611940299}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import recall_score, precision_score, accuracy_score, f1_score\n",
    "\n",
    "evaluated_result_sk = dict()\n",
    "\n",
    "evaluated_result_sk['recall']    = recall_score(test_labels, predicted_labels_sk)\n",
    "evaluated_result_sk['precision'] = precision_score(test_labels, predicted_labels_sk)\n",
    "evaluated_result_sk['accuracy']  = accuracy_score(test_labels, predicted_labels_sk)\n",
    "evaluated_result_sk['f1_score']  = f1_score(test_labels, predicted_labels_sk)\n",
    "\n",
    "print(\"Cross-Entropy-Weighted --------\")\n",
    "display(evaluated_result_CE_wgt)\n",
    "\n",
    "print(\"SkLearn based Binary Classification\")\n",
    "display(evaluated_result_sk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Understanding the affect of batch_size and step_size on the model for a given score\n",
    "batch_size_list = np.arange(50, 500, 50, dtype=np.int16)\n",
    "step_size_list  = np.arange(0.25, 0.70, 0.05, dtype=np.float16)\n",
    "\n",
    "recall_score    = np.zeros((batch_size_list.shape[0], step_size_list.shape[0]))\n",
    "accuracy_score  = np.zeros(recall_score.shape)\n",
    "precision_score = np.zeros(recall_score.shape)\n",
    "f1_score        = np.zeros(recall_score.shape)\n",
    "\n",
    "class_weights = [1, 25]\n",
    "n_iter        = 300\n",
    "initial_conditions    = [initial_weights, initial_bias] #estimated_params_CE_wgt\n",
    "\n",
    "batch_index     = 0\n",
    "step_size_index = 0\n",
    "for batch_size in batch_size_list:\n",
    "    for step_size in step_size_list:\n",
    "        estimated_params_this_iter, _ = steepest_descent(train_features[0:sample_size, 1:], \n",
    "                                                         train_labels[0:sample_size], \n",
    "                                                         initial_conditions,\n",
    "                                                         cost_function_CrossEntropy_weighted,\n",
    "                                                         model_gradient_CrossEntropy_weighted, \n",
    "                                                         n_iter=n_iter,\n",
    "                                                         step_size=step_size,\n",
    "                                                         batch_size=batch_size)\n",
    "        \n",
    "        # evaluate results\n",
    "        evaluated_metric_this_iter = evaluate(test_features[:, 1:], test_labels, estimated_params_this_iter, False)\n",
    "        \n",
    "        # store results\n",
    "        recall_score[batch_index][step_size_index]    = evaluated_metric_this_iter['Recall']\n",
    "        accuracy_score[batch_index][step_size_index]  = evaluated_metric_this_iter['Accuracy']\n",
    "        precision_score[batch_index][step_size_index] = evaluated_metric_this_iter['Precision']\n",
    "        f1_score[batch_index][step_size_index]        = evaluated_metric_this_iter['F1_Score']\n",
    "        \n",
    "        step_size_index += 1\n",
    "        print(\"percent complete: %f\"%((batch_index*step_size_list.size+step_size_index)/(recall_score.size)) )\n",
    "    \n",
    "    batch_index += 1\n",
    "    step_size_index = 0\n",
    "\n",
    "print(\"cross parameter testing --complete\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,7))\n",
    "ax = sns.heatmap(recall_score, cmap = 'YlGnBu', \n",
    "                 xticklabels=step_size_list, yticklabels=batch_size_list)\n",
    "plt.title(\"Recall Score\", fontsize=14)\n",
    "plt.xlabel('Batch size', fontsize=14)\n",
    "plt.ylabel('Step Size', fontsize=14)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "plt.figure(figsize=(12,7))\n",
    "ax = sns.heatmap(precision_score, cmap = 'YlGnBu', \n",
    "                 xticklabels=step_size_list, yticklabels=batch_size_list)\n",
    "plt.title(\"Precision Score\", fontsize=14)\n",
    "plt.xlabel('Batch size', fontsize=14)\n",
    "plt.ylabel('Step Size', fontsize=14)\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(12,7))\n",
    "ax = sns.heatmap(accuracy_score, cmap = 'YlGnBu', \n",
    "                 xticklabels=step_size_list, yticklabels=batch_size_list)\n",
    "plt.title(\"Accuracy Score\", fontsize=14)\n",
    "plt.xlabel('Batch size', fontsize=14)\n",
    "plt.ylabel('Step Size', fontsize=14)\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(12,7))\n",
    "ax = sns.heatmap(f1_score, cmap = 'YlGnBu', \n",
    "                 xticklabels=step_size_list, yticklabels=batch_size_list)\n",
    "plt.title(\"F1 Score\", fontsize=14)\n",
    "plt.xlabel('Batch size', fontsize=14)\n",
    "plt.ylabel('Step Size', fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regularization (weight-decay)\n",
    "**[Regularization_Reference](http://neuralnetworksanddeeplearning.com/chap3.html#regularization)**  \n",
    "One way to avoid over-fitting of our model is to train our samples to sufficiently large set of data. Another way to deal with this is with the concept of Regularization. There are different types of regularization (L2, L1, dropout, ...).  \n",
    "\n",
    "### L2-Regularization \n",
    "The cost function gets augmented with an additional term as below,\n",
    "$$min \\space J(X,W,b,Y) = \\frac{-1}{2N}\\left[Y^T\\log(f(X,W,b)) + (1-Y)^T\\log(1-f(X,W,b))\\right] + \\frac{\\lambda}{2N}\\sum_{W} W^2$$ \n",
    "This will make our network learn with smaller weights. One reason is to avoid model fitting to noisy data. Say, we have enough parameters that will define our training data. What if we make small adjustments to the data, let's say noise/something. If we have smaller weights, the network won't be affected by it and it'll be able to predict properly. Although there is no saying that the adjustments in the data is not valid.  \n",
    "The affect of $\\lambda$ is to give perference on the weight minimization, smaller the $\\lambda$, cost function will have smaller impact by weights. The partial derivatives of the cost will now become,  \n",
    "\\begin{eqnarray}\n",
    "\\frac{\\partial J}{\\partial W} &=& \\frac{\\partial J_0}{\\partial W} + \\frac{\\lambda}{N}W \\\\\n",
    "\\frac{\\partial J}{\\partial b} &=& \\frac{\\partial J_0}{\\partial b}\n",
    "\\end{eqnarray}\n",
    "\n",
    "This way the weight update now becomes,\n",
    "\\begin{eqnarray} \n",
    "  W & \\rightarrow & W-\\alpha \\frac{\\partial J_0}{\\partial\n",
    "    W}-\\frac{\\eta \\lambda}{N} W\\\\ \n",
    "  & = & \\left(1-\\frac{\\alpha \\lambda}{n}\\right) W -\\alpha \\frac{\\partial\n",
    "    J_0}{\\partial W}. \n",
    "\\end{eqnarray}\n",
    "The above equation will make the algorithm wanting to decay weights.  \n",
    "Note that, regularization can be on bias term as well. \n",
    "\n",
    "### L1-Regularization\n",
    "$$J = J_0 + \\frac{\\lambda}{2N}\\sum_{W} |W| $$\n",
    "where, \n",
    "\\begin{eqnarray}\n",
    "\\frac{\\partial J}{\\partial W} &=& \\frac{\\partial J_0}{\\partial W} + \\frac{\\lambda}{N}sgn(W)\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_function_CrossEntropy_regularization(data, decision_vars, class_labels, class_weight=None, weight_scaling=None):\n",
    "    # data: size (N x D)\n",
    "    # decision_vars: size (K x D)\n",
    "    # class_labels: size (K x N)\n",
    "    \n",
    "    pos_weight = 1.0\n",
    "    neg_weight = 1.0\n",
    "    if (class_weight != None):\n",
    "        neg_weight = class_weight[0]\n",
    "        pos_weight = class_weight[1]\n",
    "    \n",
    "    predicted_class = fit_model(data, decision_vars[0], decision_vars[1])\n",
    "    \n",
    "    # work around, instead of supplying 0 to log, supply some small value so as to get the desired affect in the cost\n",
    "    predicted_class = np.where(predicted_class < 1e-5, 1e-8, predicted_class)\n",
    "    \n",
    "    predicted_neg_class = 1.0 - predicted_class\n",
    "    predicted_neg_class = np.where(predicted_neg_class < 1e-5, 1e-8, predicted_neg_class)\n",
    "    \n",
    "    log_prediction_pos_class = np.log(predicted_class)\n",
    "    log_prediction_neg_class = np.log(predicted_neg_class)\n",
    "    \n",
    "    desired_neg_class = neg_weight*np.subtract(1, class_labels)\n",
    "    desired_pos_class = pos_weight*class_labels\n",
    "    \n",
    "    cross_entropy =  np.dot(log_prediction_pos_class, desired_pos_class) \\\n",
    "                   + np.dot(log_prediction_neg_class, desired_neg_class)\n",
    "      \n",
    "    cross_entropy_mean = -cross_entropy/data.shape[0]\n",
    "    \n",
    "    # add regularization component\n",
    "    if (weight_scaling != None):\n",
    "        L2_norm_sq = np.mean(np.power(decision_vars[0], 2.0))\n",
    "        L2_norm_sq = (weight_scaling/(2.0*data.shape[0])) * L2_norm_sq\n",
    "        cross_entropy_mean += L2_norm_sq\n",
    "    \n",
    "    return cross_entropy_mean\n",
    "\n",
    "\n",
    "def steepest_descent_regularization(data, class_labels, initial_conditions,\n",
    "                                     cost_func, cost_func_gradient, \n",
    "                                     n_iter=100, \n",
    "                                     step_size=0.25,\n",
    "                                     weight_scaling=0.2, # should be dependent on the batch-size to get desired affect\n",
    "                                     batch_size=100,\n",
    "                                     class_weight=None,\n",
    "                                     stopping_tol=1e-3):\n",
    "    \n",
    "    estimated_params = initial_conditions\n",
    "    cost_func_trend  = [None]*(n_iter+1)\n",
    "    \n",
    "    total_cost = cost_func(data, estimated_params, class_labels, class_weight, weight_scaling)\n",
    "    cost_func_trend[0] = total_cost\n",
    "    error = total_cost\n",
    "    \n",
    "    # weight scaling from regularization affect\n",
    "    weight_scaling_factor = (1.0 - step_size*weight_scaling/data.shape[0])\n",
    "    \n",
    "    for iteration in range(0, n_iter):\n",
    "        if (error > stopping_tol):\n",
    "            batch_indices_list = generate_batch_indices(data.shape[0], batch_size)\n",
    "\n",
    "            for batch_indices in batch_indices_list:\n",
    "                train_data   = data[batch_indices, :]\n",
    "                train_labels = class_labels[batch_indices]\n",
    "\n",
    "                gradient = cost_func_gradient(train_data, estimated_params, train_labels, class_weight)\n",
    "\n",
    "                # update Weights\n",
    "                estimated_params[0] = np.add(weight_scaling_factor*estimated_params[0], -step_size*gradient[0][0])\n",
    "\n",
    "                # update bias\n",
    "                estimated_params[1] = np.add(estimated_params[1], -step_size*gradient[1][0])\n",
    "\n",
    "            total_cost = cost_func(data, estimated_params, class_labels, class_weight, weight_scaling)\n",
    "\n",
    "            cost_func_trend[iteration+1] = total_cost\n",
    "            error = np.abs(total_cost - error)\n",
    "    \n",
    "    return estimated_params, cost_func_trend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_weights= [1, 25]\n",
    "initial_conditions = [initial_weights, initial_bias]\n",
    "estimated_params_CE_rgld, obj_func_trend_CE_rgld = steepest_descent_regularization(train_features[0:sample_size, 1:], \n",
    "                                                                                 train_labels[0:sample_size], \n",
    "                                                                                 initial_conditions,\n",
    "                                                                                 cost_function_CrossEntropy_regularization,\n",
    "                                                                                 model_gradient_CrossEntropy_weighted, \n",
    "                                                                                 n_iter=350,\n",
    "                                                                                 step_size=0.30,\n",
    "                                                                                 batch_size=500,\n",
    "                                                                                 class_weight=class_weights,\n",
    "                                                                                 weight_scaling=10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weighted + Unregularized ------ \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 117,\n",
       " 'FP': 165,\n",
       " 'FN': 24,\n",
       " 'TN': 85137,\n",
       " 'Precision': 0.4148936170212766,\n",
       " 'Recall': 0.8297872340425532,\n",
       " 'Accuracy': 0.9977879990168884,\n",
       " 'F1_Score': 0.553191489361702,\n",
       " 'confusion_matrix': prediction (col)      0    1\n",
       " actual (row)                \n",
       " 0.0               85137  165\n",
       " 1.0                  24  117}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weighted + regularized   ------ \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'TP': 120,\n",
       " 'FP': 110,\n",
       " 'FN': 21,\n",
       " 'TN': 85192,\n",
       " 'Precision': 0.5217391304347826,\n",
       " 'Recall': 0.851063829787234,\n",
       " 'Accuracy': 0.9984668141333989,\n",
       " 'F1_Score': 0.6469002695417789,\n",
       " 'confusion_matrix': prediction (col)      0    1\n",
       " actual (row)                \n",
       " 0.0               85192  110\n",
       " 1.0                  21  120}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>W_0</th>\n",
       "      <th>W_1</th>\n",
       "      <th>W_2</th>\n",
       "      <th>W_3</th>\n",
       "      <th>W_4</th>\n",
       "      <th>W_5</th>\n",
       "      <th>W_6</th>\n",
       "      <th>W_7</th>\n",
       "      <th>W_8</th>\n",
       "      <th>W_9</th>\n",
       "      <th>...</th>\n",
       "      <th>W_19</th>\n",
       "      <th>W_20</th>\n",
       "      <th>W_21</th>\n",
       "      <th>W_22</th>\n",
       "      <th>W_23</th>\n",
       "      <th>W_24</th>\n",
       "      <th>W_25</th>\n",
       "      <th>W_26</th>\n",
       "      <th>W_27</th>\n",
       "      <th>bias</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>initial</th>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.10000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CE_weighted_noRegularization</th>\n",
       "      <td>0.243628</td>\n",
       "      <td>-0.073653</td>\n",
       "      <td>0.035636</td>\n",
       "      <td>0.226936</td>\n",
       "      <td>-0.023388</td>\n",
       "      <td>-0.037312</td>\n",
       "      <td>0.015263</td>\n",
       "      <td>-0.039450</td>\n",
       "      <td>-0.113685</td>\n",
       "      <td>-0.365759</td>\n",
       "      <td>...</td>\n",
       "      <td>0.025803</td>\n",
       "      <td>-0.108191</td>\n",
       "      <td>0.256501</td>\n",
       "      <td>0.002313</td>\n",
       "      <td>-0.038070</td>\n",
       "      <td>-0.04930</td>\n",
       "      <td>-0.139865</td>\n",
       "      <td>-0.046974</td>\n",
       "      <td>0.177083</td>\n",
       "      <td>-1.040810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CE_weighted_regularization</th>\n",
       "      <td>-0.047624</td>\n",
       "      <td>0.059150</td>\n",
       "      <td>-0.052255</td>\n",
       "      <td>0.131497</td>\n",
       "      <td>-0.107453</td>\n",
       "      <td>-0.050601</td>\n",
       "      <td>-0.173839</td>\n",
       "      <td>0.069771</td>\n",
       "      <td>-0.112110</td>\n",
       "      <td>-0.299136</td>\n",
       "      <td>...</td>\n",
       "      <td>0.040009</td>\n",
       "      <td>0.023102</td>\n",
       "      <td>0.051671</td>\n",
       "      <td>-0.009547</td>\n",
       "      <td>0.000573</td>\n",
       "      <td>0.02644</td>\n",
       "      <td>-0.078496</td>\n",
       "      <td>0.087718</td>\n",
       "      <td>0.086625</td>\n",
       "      <td>-0.604303</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3 rows × 29 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   W_0       W_1       W_2       W_3  \\\n",
       "initial                       0.100000  0.100000  0.100000  0.100000   \n",
       "CE_weighted_noRegularization  0.243628 -0.073653  0.035636  0.226936   \n",
       "CE_weighted_regularization   -0.047624  0.059150 -0.052255  0.131497   \n",
       "\n",
       "                                   W_4       W_5       W_6       W_7  \\\n",
       "initial                       0.100000  0.100000  0.100000  0.100000   \n",
       "CE_weighted_noRegularization -0.023388 -0.037312  0.015263 -0.039450   \n",
       "CE_weighted_regularization   -0.107453 -0.050601 -0.173839  0.069771   \n",
       "\n",
       "                                   W_8       W_9  ...      W_19      W_20  \\\n",
       "initial                       0.100000  0.100000  ...  0.100000  0.100000   \n",
       "CE_weighted_noRegularization -0.113685 -0.365759  ...  0.025803 -0.108191   \n",
       "CE_weighted_regularization   -0.112110 -0.299136  ...  0.040009  0.023102   \n",
       "\n",
       "                                  W_21      W_22      W_23     W_24      W_25  \\\n",
       "initial                       0.100000  0.100000  0.100000  0.10000  0.100000   \n",
       "CE_weighted_noRegularization  0.256501  0.002313 -0.038070 -0.04930 -0.139865   \n",
       "CE_weighted_regularization    0.051671 -0.009547  0.000573  0.02644 -0.078496   \n",
       "\n",
       "                                  W_26      W_27      bias  \n",
       "initial                       0.100000  0.100000  0.500000  \n",
       "CE_weighted_noRegularization -0.046974  0.177083 -1.040810  \n",
       "CE_weighted_regularization    0.087718  0.086625 -0.604303  \n",
       "\n",
       "[3 rows x 29 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# evaluate results\n",
    "evaluated_result_CE_rgld = evaluate(test_features[:, 1:], test_labels, estimated_params_CE_rgld, False)\n",
    "\n",
    "# combine results together \n",
    "estimated_params = pd.DataFrame()\n",
    "estimated_params['initial']                      = np.append(initial_weights, initial_bias)\n",
    "estimated_params['CE_weighted_noRegularization'] = np.append(estimated_params_CE_wgt[0], estimated_params_CE_wgt[1])\n",
    "estimated_params['CE_weighted_regularization']   = np.append(estimated_params_CE_rgld[0], estimated_params_CE_rgld[1])\n",
    "estimated_params = estimated_params.T\n",
    "estimated_params.index = ['initial', 'CE_weighted_noRegularization', 'CE_weighted_regularization']\n",
    "estimated_params.columns = ['W_'+str(feature) for feature in range(0, NUMBER_OF_FEATURES)] + ['bias']\n",
    "\n",
    "print(\"weighted + Unregularized ------ \")\n",
    "display(evaluated_result_CE_wgt)\n",
    "\n",
    "print(\"weighted + regularized   ------ \")\n",
    "display(evaluated_result_CE_rgld)\n",
    "\n",
    "display(estimated_params)\n",
    "\n",
    "# plot trend of objective function\n",
    "plt.figure(figsize=(12,7))\n",
    "plt.plot(obj_func_trend_CE_rgld[1:], 'r-o', markersize=3, linewidth=2)\n",
    "plt.xlabel('iterations', fontsize=14)\n",
    "plt.ylabel('Objective function', fontsize=14)\n",
    "plt.title(\"class weighted cost function trend\", fontsize=14)\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "**[Latex in Markdown](https://github.com/cben/mathdown/wiki/math-in-markdown)**  \n",
    "**[Mini_Batch_Stochastic_Gradient_Descent](https://gluon.mxnet.io/chapter06_optimization/gd-sgd-scratch.html)**  \n",
    "**[Logistic_Regression_wiki](https://en.wikipedia.org/wiki/Logistic_regression)**  \n",
    "**[Logistic_Regression_ML](https://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html)**  \n",
    "**[Logistic_Regression_Andrew_NG](http://www.holehouse.org/mlclass/06_Logistic_Regression.html)**  \n",
    "**[Logistic_Regression_GitHub](https://github.com/iamkucuk/Logistic-Regression-With-Mini-Batch-Gradient-Descent/blob/master/logistic_regression_notebook.ipynb)**  \n",
    "**[Cross_Entropy_Cost_Function](http://neuralnetworksanddeeplearning.com/chap3.html)**  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}