Fraud Detection Logistic Regression-IKC dtcm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/ileanacabada/Desktop\n"
     ]
    }
   ],
   "source": [
    "cd Desktop/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 8000 entries, 0 to 7999\n",
      "Data columns (total 32 columns):\n",
      "Unnamed: 0    8000 non-null int64\n",
      "Time          8000 non-null int64\n",
      "V1            8000 non-null float64\n",
      "V2            8000 non-null float64\n",
      "V3            8000 non-null float64\n",
      "V4            8000 non-null float64\n",
      "V5            8000 non-null float64\n",
      "V6            8000 non-null float64\n",
      "V7            8000 non-null float64\n",
      "V8            8000 non-null float64\n",
      "V9            8000 non-null float64\n",
      "V10           8000 non-null float64\n",
      "V11           8000 non-null float64\n",
      "V12           8000 non-null float64\n",
      "V13           8000 non-null float64\n",
      "V14           8000 non-null float64\n",
      "V15           8000 non-null float64\n",
      "V16           8000 non-null float64\n",
      "V17           8000 non-null float64\n",
      "V18           8000 non-null float64\n",
      "V19           8000 non-null float64\n",
      "V20           8000 non-null float64\n",
      "V21           8000 non-null float64\n",
      "V22           8000 non-null float64\n",
      "V23           8000 non-null float64\n",
      "V24           8000 non-null float64\n",
      "V25           8000 non-null float64\n",
      "V26           8000 non-null float64\n",
      "V27           8000 non-null float64\n",
      "V28           8000 non-null float64\n",
      "Amount        8000 non-null float64\n",
      "Class         8000 non-null int64\n",
      "dtypes: float64(29), int64(3)\n",
      "memory usage: 2.0 MB\n",
      "None\n",
      "0    7983\n",
      "1      17\n",
      "Name: Class, dtype: int64\n",
      "0    0.997875\n",
      "1    0.002125\n",
      "Name: Class, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Import pandas and read csv\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "\n",
    "df = pd.read_csv(\"creditcard_sampledata.csv\")\n",
    "\n",
    "# Explore the features available in your dataframe\n",
    "print(df.info())\n",
    "\n",
    "# Count the occurrences of fraud and no fraud and print them\n",
    "occ = df['Class'].value_counts()\n",
    "print(occ)\n",
    "\n",
    "# Print the ratio of fraud cases\n",
    "print( occ/ len(df.index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Unnamed: 0    0\n",
       "Time          0\n",
       "V1            0\n",
       "V2            0\n",
       "V3            0\n",
       "V4            0\n",
       "V5            0\n",
       "V6            0\n",
       "V7            0\n",
       "V8            0\n",
       "V9            0\n",
       "V10           0\n",
       "V11           0\n",
       "V12           0\n",
       "V13           0\n",
       "V14           0\n",
       "V15           0\n",
       "V16           0\n",
       "V17           0\n",
       "V18           0\n",
       "V19           0\n",
       "V20           0\n",
       "V21           0\n",
       "V22           0\n",
       "V23           0\n",
       "V24           0\n",
       "V25           0\n",
       "V26           0\n",
       "V27           0\n",
       "V28           0\n",
       "Amount        0\n",
       "Class         0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isnull().values.any()\n",
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#remeber to normalize your data before applying Variance Threshold\n",
    "def variance_threshold_selector(independent_columns, variance):\n",
    "    selector = VarianceThreshold(threshold=variance)\n",
    "    selector.fit(independent_columns)\n",
    "    return independent_columns[independent_columns.columns[selector.get_support(indices=True)]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a=variance_threshold_selector(df,0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x=variance_threshold_selector(df,0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np    \n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import accuracy_score\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x=df.iloc[:,:-1]\n",
    "y= df.iloc[:,-1]\n",
    "\n",
    "#Scale your data prior to your fit thus making the coefficients comparable, and use transform in order to  select the best features\n",
    "\n",
    "def X_scaled_selector(data):\n",
    "    scaler = StandardScaler()\n",
    "    scaler.fit(data)\n",
    "    return pd.DataFrame(scaler.transform(data),columns = data.columns)\n",
    "    #return data[data.columns[scaler.get_support(indices=True)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_scaled= X_scaled_selector(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "X_scaled=x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2026: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(random_state = 0)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y,  train_size=0.3,random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=0, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_predicted= clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9991666666666666"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.score(X_train, y_train) #is the training accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9978571428571429"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_predicted) #is the testing accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "          0       1.00      1.00      1.00      5586\n",
      "          1       0.75      0.21      0.33        14\n",
      "\n",
      "avg / total       1.00      1.00      1.00      5600\n",
      "\n",
      "Confusion matrix:\n",
      " [[5585    1]\n",
      " [  11    3]]\n"
     ]
    }
   ],
   "source": [
    "#Compare y_test to predictions and obtain performance metrics\n",
    "print('Classification report:\\n', classification_report(y_test, y_predicted))\n",
    "conf_mat = confusion_matrix(y_true=y_test, y_pred=y_predicted)\n",
    "print('Confusion matrix:\\n', conf_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a0d75b2e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels = ['Class 0', 'Class 1']\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "cax = ax.matshow(conf_mat, cmap=plt.cm.Blues)\n",
    "fig.colorbar(cax)\n",
    "ax.set_xticklabels([''] + labels)\n",
    "ax.set_yticklabels([''] + labels)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Expected')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_importance = abs(clf.coef_[0])\n",
    "feature_importance = 100.0 * (feature_importance / feature_importance.max())\n",
    "sorted_idx = np.argsort(feature_importance)\n",
    "pos = np.arange(sorted_idx.shape[0]) + .5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns=np.array(x.columns)[sorted_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['V4', 'V27', 'V21', 'V13', 'Time', 'V10', 'V19', 'V15', 'V22',\n",
       "       'V23', 'Unnamed: 0', 'V25', 'V26', 'V18', 'V24', 'V12', 'V2',\n",
       "       'V28', 'V3', 'V7', 'V6', 'V9', 'V11', 'V17', 'V8', 'V1', 'Amount',\n",
       "       'V20', 'V16', 'V5', 'V14'], dtype=object)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a0d75b278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Gradient Boosting regression\n",
    "featfig = plt.figure()\n",
    "featax = featfig.add_subplot(1, 1, 1)\n",
    "featax.barh(pos, feature_importance[sorted_idx], align='center')\n",
    "featax.set_yticks(pos)\n",
    "featax.set_yticklabels(np.array(x.columns)[sorted_idx], fontsize=8)\n",
    "featax.set_xlabel('Relative Feature Importance')\n",
    "\n",
    "plt.tight_layout()   \n",
    "plt.show()"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}