outlier-methods-credit-card-fraud-detection-isolation-forest.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3 Isolation Forest    \n",
    "Isolation Forest is based on the Decision Tree algorithm. It isolates the outliers by randomly selecting a feature from the given set of features and then randomly selecting a split value between the max and min values of that feature. This random partitioning of features will produce shorter paths in trees for the anomalous data points, thus distinguishing them from the rest of the data.  \n",
    "\n",
    "\n",
    "- Isolation Forest   \n",
    "Ad: \n",
    "  - It needs small samples from large datasets so as to derive an anomaly detection function which makes it fast and\n",
    "scalable.\n",
    "  - It does not require example anomalies in the training dataset. \n",
    "  - The tree depth is the basis of its distance threshold for determining anomalies which is autonomous from the scaling of the dataset dimensions. \n",
    "  - It can both work as a supervised and an unsupervised classifier and its objective is that the anomalies are less recurrent than usual observations and vary from their values. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "reference : http://pen.ius.edu.ba/index.php/pen/article/view/533/312\n",
    "#### Acknowledgement\n",
    "https://medium.com/datadriveninvestor/credit-card-fraud-detection-using-local-outlier-factor-and-isolation-forest-in-python-56edd0a44af5\n",
    "    \n",
    "\n",
    "**Default values are**   \n",
    "\n",
    "class sklearn.ensemble.IsolationForest(*, \n",
    "- n_estimators=100, \n",
    "- max_samples='auto',  max_samples=min(256, n_samples) for auto\n",
    "- contamination='auto', \n",
    "- max_features=1.0, \n",
    "- bootstrap=False, \n",
    "- n_jobs=None, \n",
    "- behaviour='deprecated', \n",
    "- random_state=None, \n",
    "- verbose=0, \n",
    "- warm_start=False)\n",
    "\n",
    "We train for different number of estimators\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing the packages\n",
    "import datetime\n",
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from datetime import date\n",
    "import sklearn.exceptions\n",
    "from pylab import rcParams\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.svm import OneClassSVM\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.ensemble import IsolationForest\n",
    "from imblearn.under_sampling import NearMiss \n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import LocalOutlierFactor\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "from sklearn.metrics import classification_report,accuracy_score\n",
    "warnings.filterwarnings(\"ignore\", category=sklearn.exceptions.UndefinedMetricWarning)\n",
    "\n",
    "\n",
    "from numpy import asarray\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import IsolationForest\n",
    "from sklearn.neighbors import LocalOutlierFactor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(129668, 23) (27786, 23)\n"
     ]
    }
   ],
   "source": [
    "data_train = pd.read_csv(\"fraudTrain.csv\")\n",
    "data_test = pd.read_csv(\"fraudTest.csv\")\n",
    "# taking smaller sample to run the model faster\n",
    "\n",
    "df_train= data_train.sample(frac = 0.1,random_state=1)\n",
    "df_test= data_test.sample(frac = 0.05,random_state=1)\n",
    "print(df_train.shape,df_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getdatafiles():\n",
    "    # loading data\n",
    "    data_train = pd.read_csv(\"fraudTrain.csv\")\n",
    "    data_test = pd.read_csv(\"fraudTest.csv\")\n",
    "    # taking smaller sample to run the model faster\n",
    "\n",
    "    df_train= data_train.sample(frac = 0.1,random_state=1)\n",
    "    df_test= data_test.sample(frac = 0.05,random_state=1)\n",
    "    print(df_train.shape,df_test.shape)\n",
    "    \n",
    "    # function to drop tbe columns\n",
    "    def dropCol(data):\n",
    "        col_to_drop = ['trans_date_trans_time','Unnamed: 0',\n",
    "                       'cc_num','first','last','trans_num','street',\n",
    "                      'trans_date_trans_time','unix_time']\n",
    "        res = data.drop(col_to_drop,axis = 1)\n",
    "        return res\n",
    "    # dropping the columns\n",
    "    # dropping the columns ['trans_date_trans_time','Unnamed: 0','cc_num','first','last','trans_num']\n",
    "    # train data set\n",
    "    df_train = dropCol(df_train)\n",
    "    # test data set\n",
    "    df_test = dropCol(df_test)\n",
    "    \n",
    "    # creating a new feature address\n",
    "    df_train['add'] = df_train['city'] + df_train['state'] + df_train['zip'].astype(str)\n",
    "    df_test['add'] = df_test['city'] + df_test['state'] + df_test['zip'].astype(str)\n",
    "    df_train = df_train.drop(['city','state','zip'],axis =1)\n",
    "    df_test = df_test.drop(['city','state','zip'],axis =1)\n",
    "    print ( df_train.shape, df_test.shape)\n",
    "    \n",
    "\n",
    "    #Create independent and Dependent Features\n",
    "    columns = df_train.columns.tolist()\n",
    "\n",
    "    # removing the dependent feature is_fraud\n",
    "    columns = [c for c in columns if c not in [\"is_fraud\"]]\n",
    "\n",
    "    X_train = df_train[columns]\n",
    "    Y_train = df_train['is_fraud']\n",
    "    X_test = df_test[columns]\n",
    "    Y_test = df_test['is_fraud']\n",
    "    print ( X_train.shape, Y_train.shape,X_test.shape, Y_test.shape)\n",
    "\n",
    "    # function to convert dob to years\n",
    "    def age_years(born):\n",
    "        return 2019 - int(born[0:4])\n",
    "\n",
    "    # replacing the dob column with age column in our data set for test and train\n",
    "    X_train['age'] = X_train['dob'].apply(lambda x: age_years(x))\n",
    "    X_train = X_train.drop(['dob'],axis =1)\n",
    "\n",
    "    X_test['age'] = X_test['dob'].apply(lambda x: age_years(x))\n",
    "    X_test = X_test.drop(['dob'],axis =1)\n",
    "    \n",
    "    print(X_train.shape,X_test.shape)\n",
    "\n",
    "    # concanating the test and train data so that number of columns remain the same in both the data sets\n",
    "    final_df = pd.concat([X_train,X_test],axis=0)\n",
    "    final_df.shape\n",
    "\n",
    "\n",
    "    # creating the list of categorical variables\n",
    "    categorical_features =[feature for feature in X_train.columns if final_df[feature].dtypes == 'O']\n",
    "    categorical_features\n",
    "    \n",
    "    # function to convert categorical variables to one hot encoding\n",
    "    def category_onehot_multcols(data,multcolumns):\n",
    "        df_final = data\n",
    "        i=0\n",
    "        for fields in multcolumns:\n",
    "            print(fields)\n",
    "            df1=pd.get_dummies(final_df[fields],drop_first=True)\n",
    "            final_df.drop([fields],axis=1,inplace=True)\n",
    "            if i==0:\n",
    "                df_final=df1.copy()\n",
    "            else:           \n",
    "                df_final=pd.concat([df_final,df1],axis=1)\n",
    "            i=i+1             \n",
    "        df_final=pd.concat([final_df,df_final],axis=1)\n",
    "        return df_final\n",
    "\n",
    "    # applying the one hot encoding\n",
    "    final_df = category_onehot_multcols(final_df, categorical_features)\n",
    "\n",
    "    # removing duplicated columns\n",
    "    final_df =final_df.loc[:,~final_df.columns.duplicated()]\n",
    "    final_df.shape\n",
    "\n",
    "    # separating the test and training data\n",
    "    df_Train=final_df.iloc[:129668,:]\n",
    "    df_Test=final_df.iloc[129668:,:]\n",
    "    print(df_Train.shape,df_Test.shape)\n",
    "    print(Y_train.value_counts(),\"\\n\",Y_test.value_counts())\n",
    "    \n",
    "    # define standard scaler\n",
    "    scaler = StandardScaler()\n",
    "    # transform data\n",
    "    df_Train = scaler.fit_transform(df_Train)\n",
    "    df_Test = scaler.fit_transform(df_Test)# define standard scaler\n",
    "    \n",
    "    \n",
    "    \n",
    "    # files ready for testing on models\n",
    "    print(df_Train.shape, df_Test.shape, Y_train.shape, Y_test.shape)\n",
    "    return df_Train, df_Test, Y_train, Y_test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to evaluate our model \n",
    "def print_eval(y_pred,model):\n",
    "    print(\"Training Accuracy: \",model.score(df_Train, Y_train))\n",
    "    print(\"Testing Accuracy: \", model.score(df_Test, Y_test))\n",
    "    print(confusion_matrix(Y_test, y_pred))\n",
    "    \n",
    "    print(classification_report(Y_test,y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(129668, 23) (27786, 23)\n",
      "(129668, 13) (27786, 13)\n",
      "(129668, 12) (129668,) (27786, 12) (27786,)\n",
      "(129668, 12) (27786, 12)\n",
      "merchant\n",
      "category\n",
      "gender\n",
      "job\n",
      "add\n",
      "(129668, 2143) (27786, 2143)\n",
      "0    128963\n",
      "1       705\n",
      "Name: is_fraud, dtype: int64 \n",
      " 0    27656\n",
      "1      130\n",
      "Name: is_fraud, dtype: int64\n",
      "(129668, 2143) (27786, 2143) (129668,) (27786,)\n"
     ]
    }
   ],
   "source": [
    "df_Train, df_Test, Y_train, Y_test = getdatafiles()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Train, df_Test, Y_train, Y_test = getdatafiles()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normal cases in train set : 128963 \n",
      "Fraud cases in train set : 705\n",
      "Normal cases in test set : 27656 \n",
      "Fraud cases in test set : 130\n",
      "Fraud percentage : 0.0054\n",
      "Fraud percentage : 0.004678615129921543\n"
     ]
    }
   ],
   "source": [
    "## Get the Fraud and the normal  transaction numbers for test and train dataset \n",
    "\n",
    "fraud_train = df_train[df_train['is_fraud']==1]\n",
    "normal_train = df_train[df_train['is_fraud']==0]\n",
    "fraud_test = df_test[df_test['is_fraud']==1]\n",
    "normal_test = df_test[df_test['is_fraud']==0]\n",
    "\n",
    "print(\"Normal cases in train set :\",len(df_train)-len(fraud_train),\"\\nFraud cases in train set :\",len(fraud_train))\n",
    "print(\"Normal cases in test set :\",len(df_test)-len(fraud_test),\"\\nFraud cases in test set :\",len(fraud_test))\n",
    "outlier_fraction = round(len(fraud_train)/len(df_train),4)\n",
    "print(\"Fraud percentage :\", outlier_fraction)\n",
    "print(\"Fraud percentage :\", len(fraud_test)/len(df_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for different number of estimators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 15min 58s, sys: 10min 50s, total: 26min 48s\n",
      "Wall time: 27min 52s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ne = [50,75,80,85,90,95,100,200,500]\n",
    "\n",
    "outlier_fraction = len(fraud_test)/len(df_Test)\n",
    "precesion_if_1 = []\n",
    "recall_if_1 = []\n",
    "f1score_if_1 = []\n",
    "roc = []\n",
    "for n_est in ne:\n",
    "    model_isolation = IsolationForest(n_estimators = n_est,\n",
    "                                      max_samples = len(df_Test),\n",
    "                                      contamination = outlier_fraction,\n",
    "                                     random_state = 137).fit(df_Test)\n",
    "    # predictions\n",
    "    y_pred = model_isolation.predict(df_Test) # Prediction using trained model.\n",
    "    y_pred[y_pred == 1] = 0 # Valid transactions are labelled as 0.\n",
    "    y_pred[y_pred == -1] = 1 # Fraudulent transactions are labelled as 1.\n",
    "    # results \n",
    "    errors = (y_pred != Y_test).sum() # Total number of errors is calculated.\n",
    "    #print(errors_f1)\n",
    "    #print(accuracy_score(Y_test,y_pred))\n",
    "    #print(classification_report(Y_test,y_pred))\n",
    "    #print(\"roc_auc_score\",roc_auc_score(Y_test,y_pred))\n",
    "    #print(confusion_matrix(Y_test,y_pred))\n",
    "    prfs = precision_recall_fscore_support(Y_test,y_pred , average=None)\n",
    "    #res_recall[i] = round(prfs[1][1],2)\n",
    "    precesion_if_1.append(prfs[0][1])\n",
    "    \n",
    "    recall_if_1.append(prfs[1][1])\n",
    "    \n",
    "    f1score_if_1.append(prfs[2][1])\n",
    "    \n",
    "    roc.append(roc_auc_score(Y_test,y_pred))\n",
    "    recall_0   = prfs[1][0]\n",
    "    recall_1   = prfs[1][1]\n",
    "    prec_0     = prfs[0][0]\n",
    "    prec_1     = prfs[0][1]\n",
    "    f1_score_0 = prfs[2][0]\n",
    "    f1_score_1 = prfs[2][1]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.007692307692307693, 0.023076923076923078, 0.015384615384615385, 0.0, 0.0, 0.007692307692307693, 0.007692307692307693, 0.0]\n"
     ]
    }
   ],
   "source": [
    "print(recall_if_1_ne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'roc')"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x792 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "precesion_if_1_ne = precesion_if_1\n",
    "recall_if_1_ne = recall_if_1\n",
    "f1score_if_1_ne = f1score_if_1\n",
    "roc_ne = roc\n",
    "\n",
    "fig = plt.figure(1,figsize =(20,11) )\n",
    "plt.subplot(2,2,1)\n",
    "plt.plot(ne,precesion_if_1_ne)\n",
    "plt.xlabel('number of estimators')\n",
    "plt.ylabel('Precision')\n",
    "plt.title(\"Precision\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,2)\n",
    "plt.plot(ne,recall_if_1_ne)\n",
    "plt.xlabel('Number of estimators')\n",
    "plt.ylabel('Recall')\n",
    "plt.title(\"Recall\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,3)\n",
    "plt.plot(ne,f1score_if_1_ne)\n",
    "plt.xlabel('number of estimators')\n",
    "plt.ylabel('f1score')\n",
    "plt.title(\"fiscore\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,4)\n",
    "plt.plot(ne,roc_ne)\n",
    "plt.xlabel('number of estimators')\n",
    "plt.ylabel('roc')\n",
    "plt.title(\"roc\",fontsize = 16)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting roc wrt to number of estimators\n",
    "plt.plot(ne,roc)\n",
    "plt.xlabel('number of estimators')\n",
    "plt.ylabel('roc Score')\n",
    "plt.title(\"ROC\",fontsize = 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We see that 100 is the number of estimators which is giivng the best roc, we try to change the max_sample size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6min 5s, sys: 4min 1s, total: 10min 6s\n",
      "Wall time: 10min 8s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ms = [100,200,256,300,400,500,600,700,1000]\n",
    "\n",
    "outlier_fraction = len(fraud_test)/len(df_Test)\n",
    "precesion_if_1 = []\n",
    "recall_if_1 = []\n",
    "f1score_if_1 = []\n",
    "roc = []\n",
    "for max_s in ms:\n",
    "    model_isolation = IsolationForest(n_estimators = 100,\n",
    "                                      max_samples = max_s,\n",
    "                                      contamination = outlier_fraction,\n",
    "                                     random_state = 137).fit(df_Test)\n",
    "    # predictions\n",
    "    y_pred = model_isolation.predict(df_Test) # Prediction using trained model.\n",
    "    y_pred[y_pred == 1] = 0 # Valid transactions are labelled as 0.\n",
    "    y_pred[y_pred == -1] = 1 # Fraudulent transactions are labelled as 1.\n",
    "    # results \n",
    "    errors = (y_pred != Y_test).sum() # Total number of errors is calculated.\n",
    "    #print(errors_f1)\n",
    "    #print(accuracy_score(Y_test,y_pred))\n",
    "    #print(classification_report(Y_test,y_pred))\n",
    "    #print(\"roc_auc_score\",roc_auc_score(Y_test,y_pred))\n",
    "    #print(confusion_matrix(Y_test,y_pred))\n",
    "    prfs = precision_recall_fscore_support(Y_test,y_pred , average=None)\n",
    "    #res_recall[i] = round(prfs[1][1],2)\n",
    "    precesion_if_1.append(prfs[0][1])\n",
    "    recall_if_1.append(prfs[1][1])\n",
    "    f1score_if_1.append(prfs[2][1])\n",
    "    roc.append(roc_auc_score(Y_test,y_pred))\n",
    "    recall_0   = prfs[1][0]\n",
    "    recall_1   = prfs[1][1]\n",
    "    prec_0     = prfs[0][0]\n",
    "    prec_1     = prfs[0][1]\n",
    "    f1_score_0 = prfs[2][0]\n",
    "    f1_score_1 = prfs[2][1]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'ROC')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting precision,recall,f1score,roc wrt to number of estimators\n",
    "precesion_if_1_ms = precesion_if_1\n",
    "recall_if_1_ms = recall_if_1\n",
    "f1score_if_1_ms = f1score_if_1\n",
    "roc_ms = roc\n",
    "\n",
    "fig = plt.figure(1,figsize =(20,11) )\n",
    "plt.subplot(2,2,1)\n",
    "plt.plot(ne,precesion_if_1_ms)\n",
    "plt.xlabel('Number of max_samples')\n",
    "plt.ylabel('Precision')\n",
    "plt.title(\"Precision\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,2)\n",
    "plt.plot(ne,recall_if_1_ms)\n",
    "plt.xlabel('Number of max_samples')\n",
    "plt.ylabel('Recall')\n",
    "plt.title(\"Recall\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,3)\n",
    "plt.plot(ne,f1score_if_1_ms)\n",
    "plt.xlabel('number of max_samples')\n",
    "plt.ylabel('f1score')\n",
    "plt.title(\"fiscore\",fontsize = 16)\n",
    "\n",
    "plt.subplot(2,2,4)\n",
    "plt.plot(ne,roc_ms)\n",
    "plt.xlabel('number of max_samples')\n",
    "plt.ylabel('roc')\n",
    "plt.title(\"roc\",fontsize = 16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.0, 0.0, 0.015384615384615385, 0.0]\n"
     ]
    }
   ],
   "source": [
    "print(recall_if_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WE choose maximum number of samples as 500, number of estimators as 100 and now we test for contamination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9min 46s, sys: 6min 16s, total: 16min 3s\n",
      "Wall time: 16min 10s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "cn = [.001,.005,.006,.007,.008,.01,.02,.1]\n",
    "\n",
    "outlier_fraction = len(fraud_test)/len(df_Test)\n",
    "precesion_if_1 = []\n",
    "recall_if_1 = []\n",
    "f1score_if_1 = []\n",
    "roc = []\n",
    "for cnr in cn:\n",
    "    model_isolation = IsolationForest(n_estimators = 100,\n",
    "                                      max_samples = 500,\n",
    "                                      contamination = cnr,\n",
    "                                     random_state = 137).fit(df_Test)\n",
    "    # predictions\n",
    "    y_pred = model_isolation.predict(df_Test) # Prediction using trained model.\n",
    "    y_pred[y_pred == 1] = 0 # Valid transactions are labelled as 0.\n",
    "    y_pred[y_pred == -1] = 1 # Fraudulent transactions are labelled as 1.\n",
    "    # results \n",
    "    errors = (y_pred != Y_test).sum() # Total number of errors is calculated.\n",
    "    #print(errors_f1)\n",
    "    #print(accuracy_score(Y_test,y_pred))\n",
    "    #print(classification_report(Y_test,y_pred))\n",
    "    #print(\"roc_auc_score\",roc_auc_score(Y_test,y_pred))\n",
    "    #print(confusion_matrix(Y_test,y_pred))\n",
    "    prfs = precision_recall_fscore_support(Y_test,y_pred , average=None)\n",
    "    #res_recall[i] = round(prfs[1][1],2)\n",
    "    precesion_if_1.append(prfs[0][1])\n",
    "    recall_if_1.append(prfs[1][1])\n",
    "    f1score_if_1.append(prfs[2][1])\n",
    "    roc.append(roc_auc_score(Y_test,y_pred))\n",
    "    recall_0   = prfs[1][0]\n",
    "    recall_1   = prfs[1][1]\n",
    "    prec_0     = prfs[0][0]\n",
    "    prec_1     = prfs[0][1]\n",
    "    f1_score_0 = prfs[2][0]\n",
    "    f1_score_1 = prfs[2][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.014869888475836432, 0.0202020202020202, 0.018461538461538463, 0.016997167138810203, 0.014705882352941176, 0.01457725947521866, 0.012375386730835339]\n"
     ]
    }
   ],
   "source": [
    "print(f1score_if_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'ROC plot as per Contamination Rate')"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting roc wrt to number of estimators\n",
    "\n",
    "\n",
    "plt.plot(cn,f1score_if_1)\n",
    "plt.xlabel('Contamination Rate')\n",
    "plt.ylabel('roc Score')\n",
    "plt.title(\"ROC plot as per Contamination Rate\",fontsize = 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We choose maximum number of samples is 500, number of estimators is 100 and contamination ratio is 0.005 which is the actual contamination ration\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 13s, sys: 49.4 s, total: 2min 3s\n",
      "Wall time: 2min 15s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# final results without any optimization\n",
    "model_isolation = IsolationForest(n_estimators = 100,\n",
    "                                      max_samples = 500,\n",
    "                                      contamination = outlier_fraction,\n",
    "                                     random_state = 137).fit(df_Test)\n",
    "# predictions\n",
    "y_pred = model_isolation.predict(df_Test) # Prediction using trained model.\n",
    "y_pred[y_pred == 1] = 0 # Valid transactions are labelled as 0.\n",
    "y_pred[y_pred == -1] = 1 # Fraudulent transactions are labelled as 1.\n",
    "# results \n",
    "errors = (y_pred != Y_test).sum() # Total number of errors is calculated.\n",
    "#print(errors_f1)\n",
    "#print(accuracy_score(Y_test,y_pred))\n",
    "#print(classification_report(Y_test,y_pred))\n",
    "#print(\"roc_auc_score\",roc_auc_score(Y_test,y_pred))\n",
    "#print(confusion_matrix(Y_test,y_pred))\n",
    "prfs = precision_recall_fscore_support(Y_test,y_pred , average=None)\n",
    "#res_recall[i] = round(prfs[1][1],2)\n",
    "precesion_if_1.append(prfs[0][1])\n",
    "recall_if_1.append(prfs[1][1])\n",
    "f1score_if_1.append(prfs[2][1])\n",
    "roc.append(roc_auc_score(Y_test,y_pred))\n",
    "recall_0   = prfs[1][0]\n",
    "recall_1   = prfs[1][1]\n",
    "prec_0     = prfs[0][0]\n",
    "prec_1     = prfs[0][1]\n",
    "f1_score_0 = prfs[2][0]\n",
    "f1_score_1 = prfs[2][1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[27528   128]\n",
      " [  128     2]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(Y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.015384615384615385 0.015384615384615385 0.015384615384615385\n"
     ]
    }
   ],
   "source": [
    "print(prec_1,recall_1,f1_score_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install eif==1.0.2\n",
    "import eif as iso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretty_cm(y_pred, y_truth, labels):\n",
    "    '''\n",
    "    'Pretty' implementation of a confusion matrix with some evaluation statistics.\n",
    "    \n",
    "    Input:\n",
    "    y_pred - object with class predictions from the model\n",
    "    y_truth - object with actual classes\n",
    "    labels - list containing label names\n",
    "    '''\n",
    "    \n",
    "    cm = metrics.confusion_matrix(y_truth, y_pred)\n",
    "    ax= plt.subplot()\n",
    "    sns.heatmap(cm, annot=True, fmt=\"d\", linewidths=.5, square = True, cmap = 'BuGn_r')\n",
    "    ax.set_xlabel('Predicted label')\n",
    "    ax.set_ylabel('Actual label')\n",
    "    ax.set_title('Confusion Matrix', size = 15) \n",
    "    ax.xaxis.set_ticklabels(labels)\n",
    "    ax.yaxis.set_ticklabels(labels)\n",
    "    \n",
    "    print('#######################')\n",
    "    print('Evaluation metrics ####')\n",
    "    print('#######################')\n",
    "    print('Accuracy: {:.4f}'.format(metrics.accuracy_score(y_truth, y_pred)))\n",
    "    print('Precision: {:.4f}'.format(metrics.precision_score(y_truth, y_pred)))\n",
    "    print('Recall: {:.4f}'.format(metrics.recall_score(y_truth, y_pred)))\n",
    "    print('F1: {:.4f}'.format(metrics.f1_score(y_truth, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 11s, sys: 44.8 s, total: 1min 55s\n",
      "Wall time: 1min 56s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "if_sk = IsolationForest(n_estimators = 100, \n",
    "                        max_samples = 500,\n",
    "                        contamination = 0.005, \n",
    "                        \n",
    "                        random_state = np.random.RandomState(42))\n",
    "if_sk.fit(df_Test)\n",
    "y_pred = if_sk.predict(df_Test)\n",
    "y_pred = [1 if x == -1 else 0 for x in y_pred]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### https://github.com/erykml/medium_articles/blob/master/Machine%20Learning/extended_isolation_forest_example.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#######################\n",
      "Evaluation metrics ####\n",
      "#######################\n",
      "Accuracy: 0.9905\n",
      "Precision: 0.0144\n",
      "Recall: 0.0154\n",
      "F1: 0.0149\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pretty_cm(y_pred, Y_test, [0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.1586771 , -0.15772542,  0.31440033, ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276],\n",
       "       [-0.09945886,  0.1222537 ,  0.4049271 , ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276],\n",
       "       [-0.3738404 ,  1.7963373 , -0.42691076, ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276],\n",
       "       ...,\n",
       "       [-0.37472426, -0.29972801,  0.85060634, ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276],\n",
       "       [ 0.58044612, -0.15106161,  0.95140742, ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276],\n",
       "       [-0.27970991, -1.29368663, -0.64467186, ..., -0.02324074,\n",
       "        -0.0355136 , -0.03448276]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(df_Test).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomalies_ratio = 0.005\n",
    "if_eif = iso.iForest(df_Test, \n",
    "                     ntrees = 100, \n",
    "                     sample_size = 500, \n",
    "                     ExtensionLevel = 0)\n",
    "\n",
    "# calculate anomaly scores\n",
    "anomaly_scores = if_eif.compute_paths(X_in = df_Test)\n",
    "# sort the scores\n",
    "anomaly_scores_sorted = np.argsort(anomaly_scores)\n",
    "# retrieve indices of anomalous observations\n",
    "indices_with_preds = anomaly_scores_sorted[-int(np.ceil(.005* df_Test.shape[0])):]\n",
    "# create predictions \n",
    "y_pred = np.zeros_like(Y_test)\n",
    "y_pred[indices_with_preds] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#######################\n",
      "Evaluation metrics ####\n",
      "#######################\n",
      "Accuracy: 0.9903\n",
      "Precision: 0.0000\n",
      "Recall: 0.0000\n",
      "F1: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pretty_cm(y_pred, Y_test, [0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#######################\n",
      "Evaluation metrics ####\n",
      "#######################\n",
      "Accuracy: 0.9910\n",
      "Precision: 0.0647\n",
      "Recall: 0.0692\n",
      "F1: 0.0669\n",
      "CPU times: user 12min 2s, sys: 20.6 s, total: 12min 23s\n",
      "Wall time: 11min 50s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "anomalies_ratio = 0.005\n",
    "if_eif = iso.iForest(df_Test, \n",
    "                     ntrees = 100, \n",
    "                     sample_size = 500, \n",
    "                     ExtensionLevel = df_Test.shape[1] - 1)\n",
    "\n",
    "# calculate anomaly scores\n",
    "anomaly_scores = if_eif.compute_paths(X_in = df_Test)\n",
    "# sort the scores\n",
    "anomaly_scores_sorted = np.argsort(anomaly_scores)\n",
    "# retrieve indices of anomalous observations\n",
    "indices_with_preds = anomaly_scores_sorted[-int(np.ceil(.005* df_Test.shape[0])):]\n",
    "# create predictions \n",
    "y_pred = np.zeros_like(Y_test)\n",
    "y_pred[indices_with_preds] = 1\n",
    "pretty_cm(y_pred, Y_test, [0, 1])"
   ]
  },
  {
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}