Credit Card Fraud Detection Decision Tree.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('C:/Users/nsida/OneDrive/Desktop/creditcard.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling down the features\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "data['normalizedAmount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data.iloc[:, data.columns != 'Class']\n",
    "y = data.iloc[:, data.columns == 'Class']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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.3, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "decision_tree = DecisionTreeClassifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n",
       "            max_features=None, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decision_tree.fit(X_train, y_train.values.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n",
       "            max_features=None, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decision_tree.fit(X_train,y_train.values.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = decision_tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9992509626300574"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decision_tree.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from sklearn import svm, datasets\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = decision_tree.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_expected = pd.DataFrame(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[284288     27]\n",
      " [    37    455]]\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": [
    "cnf_matrix = confusion_matrix(y_expected, y_pred.round())\n",
    "plot_confusion_matrix(cnf_matrix,classes=[0,1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "492\n"
     ]
    }
   ],
   "source": [
    "fraud_indices = np.array(data[data.Class == 1].index)\n",
    "number_records_fraud = len(fraud_indices)\n",
    "print(number_records_fraud)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'random_normal_indices' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-551cded31a26>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0munder_sample_indices\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mfraud_indices\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrandom_normal_indices\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0munder_sample_indices\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'random_normal_indices' is not defined"
     ]
    }
   ],
   "source": [
    "under_sample_indices = np.concatenate([fraud_indices,random_normal_indices])\n",
    "print(len(under_sample_indices))"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}