Credit card Fraud Detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Source of dataset\n",
    "https://www.kaggle.com/mlg-ulb/creditcardfraud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv(\"creditcard.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore the features in the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For confidential reasons, the PCA transformation has already been performed in this dataset\n",
    "### Hence the variable headers or the values may not seem intuitive\n",
    "### However, this will not be huge issue in order to demonstrate our use case. Here 'Class' is the target/dependent variable that depicts whether a particular transaction is fraud or non-fraud where 1 denotes fraud and 0 denotes non-fraud. This is a highly imbalanced dataset with Number of Frauds being only 0.2%\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 284807 entries, 0 to 284806\n",
      "Data columns (total 31 columns):\n",
      "Time      284807 non-null float64\n",
      "V1        284807 non-null float64\n",
      "V2        284807 non-null float64\n",
      "V3        284807 non-null float64\n",
      "V4        284807 non-null float64\n",
      "V5        284807 non-null float64\n",
      "V6        284807 non-null float64\n",
      "V7        284807 non-null float64\n",
      "V8        284807 non-null float64\n",
      "V9        284807 non-null float64\n",
      "V10       284807 non-null float64\n",
      "V11       284807 non-null float64\n",
      "V12       284807 non-null float64\n",
      "V13       284807 non-null float64\n",
      "V14       284807 non-null float64\n",
      "V15       284807 non-null float64\n",
      "V16       284807 non-null float64\n",
      "V17       284807 non-null float64\n",
      "V18       284807 non-null float64\n",
      "V19       284807 non-null float64\n",
      "V20       284807 non-null float64\n",
      "V21       284807 non-null float64\n",
      "V22       284807 non-null float64\n",
      "V23       284807 non-null float64\n",
      "V24       284807 non-null float64\n",
      "V25       284807 non-null float64\n",
      "V26       284807 non-null float64\n",
      "V27       284807 non-null float64\n",
      "V28       284807 non-null float64\n",
      "Amount    284807 non-null float64\n",
      "Class     284807 non-null int64\n",
      "dtypes: float64(30), int64(1)\n",
      "memory usage: 67.4 MB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(dataset.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    284315\n",
      "1       492\n",
      "Name: Class, dtype: int64\n",
      "0    0.998273\n",
      "1    0.001727\n",
      "Name: Class, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Count number of Fraud cases as a ratio of total transactions in the data\n",
    "\n",
    "count = dataset['Class'].value_counts()\n",
    "print(count)\n",
    "print(count / len(dataset.index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independent variables and Target/Dependent variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dataset.iloc[:, 2:30].values\n",
    "y = dataset.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plt.scatter(x[y == 0, 0], x[y == 0, 1], label=\"Class #0: Non-Fraud\", alpha=0.5, linewidth=0.15)\n",
    "plt.scatter(x[y == 1, 0], x[y == 1, 1], label=\"Class #1: Fraud\", alpha=0.5, linewidth=0.15, c='r')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split into training and test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "x_train,x_test,y_train,y_test = train_test_split (x,y, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(criterion='entropy', n_estimators=10, random_state=0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the model\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "classifier = RandomForestClassifier(n_estimators=10,criterion='entropy', random_state=0)\n",
    "classifier.fit(x_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict Y on the test set\n",
    "y_pred = classifier.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifcation report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00     56861\n",
      "           1       0.94      0.75      0.84       101\n",
      "\n",
      "    accuracy                           1.00     56962\n",
      "   macro avg       0.97      0.88      0.92     56962\n",
      "weighted avg       1.00      1.00      1.00     56962\n",
      "\n",
      "Confusion matrix:\n",
      " [[56856     5]\n",
      " [   25    76]]\n"
     ]
    }
   ],
   "source": [
    "# Obtain the results from the classification report and confusion matrix \n",
    "from sklearn.metrics import  classification_report, confusion_matrix \n",
    "\n",
    "print('Classifcation report:\\n', classification_report(y_test, y_pred))\n",
    "conf_mat = confusion_matrix(y_true=y_test, y_pred=y_pred)\n",
    "print('Confusion matrix:\\n', conf_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explanation of the results\n",
    "With Random forest with basic default settings, we get pretty good accuracy and precision of 94%. \n",
    "But note that the recall is 75%. In this case,more than precision we are more concerned about recall because we want to catch as many fraudulent cases as possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Undersampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifcation report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.98      0.99     56861\n",
      "           1       0.07      0.89      0.13       101\n",
      "\n",
      "    accuracy                           0.98     56962\n",
      "   macro avg       0.53      0.93      0.56     56962\n",
      "weighted avg       1.00      0.98      0.99     56962\n",
      "\n",
      "Confusion matrix:\n",
      " [[55614  1247]\n",
      " [   11    90]]\n"
     ]
    }
   ],
   "source": [
    "# This is the pipeline module we need from imblearn\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from imblearn.pipeline import Pipeline \n",
    "\n",
    "# Define which resampling method and which ML model to use in the pipeline\n",
    "resampling = RandomUnderSampler()\n",
    "model = RandomForestClassifier(n_estimators=10,criterion='entropy', random_state=0)\n",
    "\n",
    "# Define the pipeline,and combine sampling method with the RF model\n",
    "pipeline = Pipeline([('RandomUnderSampler', resampling), ('RF', model)])\n",
    "\n",
    "pipeline.fit(x_train, y_train) \n",
    "predicted = pipeline.predict(x_test)\n",
    "\n",
    "# Obtain the results from the classification report and confusion matrix \n",
    "print('Classifcation report:\\n', classification_report(y_test, predicted))\n",
    "conf_mat = confusion_matrix(y_true=y_test, y_pred=predicted)\n",
    "print('Confusion matrix:\\n', conf_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With undersampling the recall improves to 89% and we are able to capture more Frauds (90 vs 76).But precision drops a lot and so does the F-score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifcation report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00     56861\n",
      "           1       0.95      0.81      0.88       101\n",
      "\n",
      "    accuracy                           1.00     56962\n",
      "   macro avg       0.98      0.91      0.94     56962\n",
      "weighted avg       1.00      1.00      1.00     56962\n",
      "\n",
      "Confusion matrix:\n",
      " [[56857     4]\n",
      " [   19    82]]\n"
     ]
    }
   ],
   "source": [
    "# This is the pipeline module we need from imblearn\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "\n",
    "# Define which resampling method and which ML model to use in the pipeline\n",
    "resampling = RandomOverSampler()\n",
    "model = RandomForestClassifier(n_estimators=10,criterion='entropy', random_state=0)\n",
    "\n",
    "# Define the pipeline,and combine sampling method with the RF model\n",
    "pipeline = Pipeline([('RandomOverSampler', resampling), ('RF', model)])\n",
    "\n",
    "pipeline.fit(x_train, y_train) \n",
    "predicted = pipeline.predict(x_test)\n",
    "\n",
    "# Obtain the results from the classification report and confusion matrix \n",
    "print('Classifcation report:\\n', classification_report(y_test, predicted))\n",
    "conf_mat = confusion_matrix(y_true=y_test, y_pred=predicted)\n",
    "print('Confusion matrix:\\n', conf_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With oversampling, we can capture more frauds (82 vs 76). Here the accuracy and F-score has also improved along with precision."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SMOTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifcation report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00     56861\n",
      "           1       0.85      0.84      0.85       101\n",
      "\n",
      "    accuracy                           1.00     56962\n",
      "   macro avg       0.92      0.92      0.92     56962\n",
      "weighted avg       1.00      1.00      1.00     56962\n",
      "\n",
      "Confusion matrix:\n",
      " [[56846    15]\n",
      " [   16    85]]\n"
     ]
    }
   ],
   "source": [
    "# This is the pipeline module we need from imblearn\n",
    "\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "\n",
    "# Define which resampling method and which ML model to use in the pipeline\n",
    "resampling = SMOTE(sampling_strategy='auto',random_state=0)\n",
    "model = RandomForestClassifier(n_estimators=10,criterion='entropy', random_state=0)\n",
    "\n",
    "# Define the pipeline, tell it to combine SMOTE with the RF model\n",
    "pipeline = Pipeline([('SMOTE', resampling), ('RF', model)])\n",
    "\n",
    "pipeline.fit(x_train, y_train) \n",
    "predicted = pipeline.predict(x_test)\n",
    "\n",
    "# Obtain the results from the classification report and confusion matrix \n",
    "print('Classifcation report:\\n', classification_report(y_test, predicted))\n",
    "conf_mat = confusion_matrix(y_true=y_test, y_pred=predicted)\n",
    "print('Confusion matrix:\\n', conf_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With SMOTE results are similar, but we are able to capture 1 more fraud from simple oversampling. The recall has also improved, though the false postives have increased now to 15 vs 4 earlier"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}