diff --git a/your-code/lab_imbalance.ipynb b/your-code/lab_imbalance.ipynb index dbb15e1..f1ac2c4 100644 --- a/your-code/lab_imbalance.ipynb +++ b/your-code/lab_imbalance.ipynb @@ -1,147 +1,1309 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Inbalanced Classes\n", - "## In this lab, we are going to explore a case of imbalanced classes. \n", - "\n", - "\n", - "Like we disussed in class, when we have noisy data, if we are not careful, we can end up fitting our model to the noise in the data and not the 'signal'-- the factors that actually determine the outcome. This is called overfitting, and results in good results in training, and in bad results when the model is applied to real data. Similarly, we could have a model that is too simplistic to accurately model the signal. This produces a model that doesnt work well (ever). \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First, download the data from: https://www.kaggle.com/datasets/chitwanmanchanda/fraudulent-transactions-data?resource=download . Import the dataset and provide some discriptive statistics and plots. What do you think will be the important features in determining the outcome?\n", - "### Note: don't use the entire dataset, use a sample instead, with n=100000 elements, so your computer doesn't freeze." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### What is the distribution of the outcome? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your response here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Clean the dataset. Pre-process it to make it suitable for ML training. Feel free to explore, drop, encode, transform, etc. Whatever you feel will improve the model score." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run a logisitc regression classifier and evaluate its accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Now pick a model of your choice and evaluate its accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Which model worked better and how do you know?" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Your response here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." - ] - } - ], - "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 -} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inbalanced Classes\n", + "## In this lab, we are going to explore a case of imbalanced classes. \n", + "\n", + "\n", + "Like we disussed in class, when we have noisy data, if we are not careful, we can end up fitting our model to the noise in the data and not the 'signal'-- the factors that actually determine the outcome. This is called overfitting, and results in good results in training, and in bad results when the model is applied to real data. Similarly, we could have a model that is too simplistic to accurately model the signal. This produces a model that doesnt work well (ever). \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### First, download the data from: https://www.kaggle.com/datasets/chitwanmanchanda/fraudulent-transactions-data?resource=download . Import the dataset and provide some discriptive statistics and plots. What do you think will be the important features in determining the outcome?\n", + "### Note: don't use the entire dataset, use a sample instead, with n=100000 elements, so your computer doesn't freeze." + ] + }, + { + "cell_type": "code", + "execution_count": 586, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sn\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 587, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here\n", + "num_rows = 100000\n", + "data = pd.read_csv('Fraud.csv', nrows=num_rows)" + ] + }, + { + "cell_type": "code", + "execution_count": 588, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
steptypeamountnameOrigoldbalanceOrgnewbalanceOrignameDestoldbalanceDestnewbalanceDestisFraudisFlaggedFraud
01PAYMENT9839.64C1231006815170136.0160296.36M19797871550.00.000
11PAYMENT1864.28C166654429521249.019384.72M20442822250.00.000
21TRANSFER181.00C1305486145181.00.00C5532640650.00.010
31CASH_OUT181.00C840083671181.00.00C3899701021182.00.010
41PAYMENT11668.14C204853772041554.029885.86M12307017030.00.000
\n", + "
" + ], + "text/plain": [ + " step type amount nameOrig oldbalanceOrg newbalanceOrig \\\n", + "0 1 PAYMENT 9839.64 C1231006815 170136.0 160296.36 \n", + "1 1 PAYMENT 1864.28 C1666544295 21249.0 19384.72 \n", + "2 1 TRANSFER 181.00 C1305486145 181.0 0.00 \n", + "3 1 CASH_OUT 181.00 C840083671 181.0 0.00 \n", + "4 1 PAYMENT 11668.14 C2048537720 41554.0 29885.86 \n", + "\n", + " nameDest oldbalanceDest newbalanceDest isFraud isFlaggedFraud \n", + "0 M1979787155 0.0 0.0 0 0 \n", + "1 M2044282225 0.0 0.0 0 0 \n", + "2 C553264065 0.0 0.0 1 0 \n", + "3 C38997010 21182.0 0.0 1 0 \n", + "4 M1230701703 0.0 0.0 0 0 " + ] + }, + "execution_count": 588, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### What is the distribution of the outcome? " + ] + }, + { + "cell_type": "code", + "execution_count": 589, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 99884\n", + "1 116\n", + "Name: isFraud, dtype: int64" + ] + }, + "execution_count": 589, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your response here\n", + "data['isFraud'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Clean the dataset. Pre-process it to make it suitable for ML training. Feel free to explore, drop, encode, transform, etc. Whatever you feel will improve the model score." + ] + }, + { + "cell_type": "code", + "execution_count": 590, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 100000 entries, 0 to 99999\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 step 100000 non-null int64 \n", + " 1 type 100000 non-null object \n", + " 2 amount 100000 non-null float64\n", + " 3 nameOrig 100000 non-null object \n", + " 4 oldbalanceOrg 100000 non-null float64\n", + " 5 newbalanceOrig 100000 non-null float64\n", + " 6 nameDest 100000 non-null object \n", + " 7 oldbalanceDest 100000 non-null float64\n", + " 8 newbalanceDest 100000 non-null float64\n", + " 9 isFraud 100000 non-null int64 \n", + " 10 isFlaggedFraud 100000 non-null int64 \n", + "dtypes: float64(5), int64(3), object(3)\n", + "memory usage: 8.4+ MB\n" + ] + } + ], + "source": [ + "# Your code here\n", + "data.info()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 591, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stepamountoldbalanceOrgnewbalanceOrigoldbalanceDestnewbalanceDestisFraudisFlaggedFraud
count100000.0000001.000000e+051.000000e+051.000000e+051.000000e+051.000000e+05100000.000000100000.0
mean8.4996401.736022e+058.777575e+058.940619e+058.805048e+051.184041e+060.0011600.0
std1.8255453.443003e+052.673284e+062.711318e+062.402267e+062.802350e+060.0340390.0
min1.0000003.200000e-010.000000e+000.000000e+000.000000e+000.000000e+000.0000000.0
25%8.0000009.963562e+030.000000e+000.000000e+000.000000e+000.000000e+000.0000000.0
50%9.0000005.274552e+042.006150e+040.000000e+002.083943e+044.990918e+040.0000000.0
75%10.0000002.117631e+051.901920e+052.148132e+055.882724e+051.058186e+060.0000000.0
max10.0000001.000000e+073.379739e+073.400874e+073.400874e+073.894623e+071.0000000.0
\n", + "
" + ], + "text/plain": [ + " step amount oldbalanceOrg newbalanceOrig \\\n", + "count 100000.000000 1.000000e+05 1.000000e+05 1.000000e+05 \n", + "mean 8.499640 1.736022e+05 8.777575e+05 8.940619e+05 \n", + "std 1.825545 3.443003e+05 2.673284e+06 2.711318e+06 \n", + "min 1.000000 3.200000e-01 0.000000e+00 0.000000e+00 \n", + "25% 8.000000 9.963562e+03 0.000000e+00 0.000000e+00 \n", + "50% 9.000000 5.274552e+04 2.006150e+04 0.000000e+00 \n", + "75% 10.000000 2.117631e+05 1.901920e+05 2.148132e+05 \n", + "max 10.000000 1.000000e+07 3.379739e+07 3.400874e+07 \n", + "\n", + " oldbalanceDest newbalanceDest isFraud isFlaggedFraud \n", + "count 1.000000e+05 1.000000e+05 100000.000000 100000.0 \n", + "mean 8.805048e+05 1.184041e+06 0.001160 0.0 \n", + "std 2.402267e+06 2.802350e+06 0.034039 0.0 \n", + "min 0.000000e+00 0.000000e+00 0.000000 0.0 \n", + "25% 0.000000e+00 0.000000e+00 0.000000 0.0 \n", + "50% 2.083943e+04 4.990918e+04 0.000000 0.0 \n", + "75% 5.882724e+05 1.058186e+06 0.000000 0.0 \n", + "max 3.400874e+07 3.894623e+07 1.000000 0.0 " + ] + }, + "execution_count": 591, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 592, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "corr = data.select_dtypes(include=['int64', 'float64']).corr()\n", + "#Set up mask for triangle representation\n", + "mask = np.zeros_like(corr, dtype=np.bool_)\n", + "mask[np.triu_indices_from(mask)] = True\n", + "\n", + "# Set up the matplotlib figure\n", + "f, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "# Generate a custom diverging colormap\n", + "cmap = 'coolwarm'\n", + "\n", + "# Draw the heatmap with the mask and correct aspect ratio\n", + "sn.heatmap(corr, cmap=cmap, mask=mask, vmax=1,square=True, linewidths=.5, cbar_kws={\"shrink\": .5},annot = corr)\n", + "plt.xticks(rotation=90)\n", + "plt.yticks(rotation=0)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 593, + "metadata": {}, + "outputs": [], + "source": [ + "data['newbalanceDest-oldbalanceDest'] = data['newbalanceDest']- data['oldbalanceDest']\n", + "data['newbalanceOrg-oldbalanceOrg'] = data['newbalanceOrig']- data['oldbalanceOrg']" + ] + }, + { + "cell_type": "code", + "execution_count": 594, + "metadata": {}, + "outputs": [], + "source": [ + "#drop 'oldbalanceOrg' column because of the high collinearity with 'newbalanceOrig'.\n", + "#drop 'oldbalanceDest' column because of the high collinearity with 'newbalanceDest'.\n", + "\n", + "data.drop(columns=['oldbalanceOrg','oldbalanceDest'], inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 595, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "step int64\n", + "type object\n", + "amount float64\n", + "nameOrig object\n", + "newbalanceOrig float64\n", + "nameDest object\n", + "newbalanceDest float64\n", + "isFraud int64\n", + "isFlaggedFraud int64\n", + "newbalanceDest-oldbalanceDest float64\n", + "newbalanceOrg-oldbalanceOrg float64\n", + "dtype: object" + ] + }, + "execution_count": 595, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.dtypes" + ] + }, + { + "cell_type": "code", + "execution_count": 596, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9 37628\n", + "10 27274\n", + "8 21097\n", + "7 6837\n", + "1 2708\n", + "6 1660\n", + "2 1014\n", + "5 665\n", + "4 565\n", + "3 552\n", + "Name: step, dtype: int64" + ] + }, + "execution_count": 596, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['step'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 597, + "metadata": {}, + "outputs": [], + "source": [ + "data['step'] = data['step'].astype(str)" + ] + }, + { + "cell_type": "code", + "execution_count": 598, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PAYMENT 39512\n", + "CASH_OUT 30718\n", + "CASH_IN 20185\n", + "TRANSFER 8597\n", + "DEBIT 988\n", + "Name: type, dtype: int64" + ] + }, + "execution_count": 598, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['type'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 599, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "C1231006815 1\n", + "C1407775146 1\n", + "C1802124274 1\n", + "C1910868687 1\n", + "C579725406 1\n", + " ..\n", + "C668560116 1\n", + "C986934168 1\n", + "C1567015632 1\n", + "C1280981431 1\n", + "C1868032458 1\n", + "Name: nameOrig, Length: 100000, dtype: int64" + ] + }, + "execution_count": 599, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['nameOrig'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 600, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "C985934102 78\n", + "C1286084959 72\n", + "C248609774 71\n", + "C1590550415 69\n", + "C2083562754 66\n", + " ..\n", + "M259075709 1\n", + "M375566378 1\n", + "M1225444842 1\n", + "M1709995863 1\n", + "M1419201886 1\n", + "Name: nameDest, Length: 51551, dtype: int64" + ] + }, + "execution_count": 600, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['nameDest'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 601, + "metadata": {}, + "outputs": [], + "source": [ + "data['nameDest-is Fraud'] = data.groupby('nameDest')['isFraud'].transform('mean')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 602, + "metadata": {}, + "outputs": [], + "source": [ + "data['nameDest'] = data['nameDest'].astype(str).str.replace('C', '').str.replace('M', '').astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 603, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 100000\n", + "Name: isFlaggedFraud, dtype: int64" + ] + }, + "execution_count": 603, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['isFlaggedFraud'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 604, + "metadata": {}, + "outputs": [], + "source": [ + "data.drop(columns=['nameOrig','isFlaggedFraud'], inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 605, + "metadata": {}, + "outputs": [], + "source": [ + "data_dummy = pd.get_dummies(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 606, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
amountnewbalanceOrignameDestnewbalanceDestisFraudnewbalanceDest-oldbalanceDestnewbalanceOrg-oldbalanceOrgnameDest-is Fraudstep_1step_10...step_5step_6step_7step_8step_9type_CASH_INtype_CASH_OUTtype_DEBITtype_PAYMENTtype_TRANSFER
09839.64160296.3619797871550.000.0-9839.640.00000010...0000000010
11864.2819384.7220442822250.000.0-1864.280.00000010...0000000010
2181.000.005532640650.010.0-181.000.14285710...0000000001
3181.000.00389970100.01-21182.0-181.000.20000010...0000001000
411668.1429885.8612307017030.000.0-11668.140.00000010...0000000010
\n", + "

5 rows × 23 columns

\n", + "
" + ], + "text/plain": [ + " amount newbalanceOrig nameDest newbalanceDest isFraud \\\n", + "0 9839.64 160296.36 1979787155 0.0 0 \n", + "1 1864.28 19384.72 2044282225 0.0 0 \n", + "2 181.00 0.00 553264065 0.0 1 \n", + "3 181.00 0.00 38997010 0.0 1 \n", + "4 11668.14 29885.86 1230701703 0.0 0 \n", + "\n", + " newbalanceDest-oldbalanceDest newbalanceOrg-oldbalanceOrg \\\n", + "0 0.0 -9839.64 \n", + "1 0.0 -1864.28 \n", + "2 0.0 -181.00 \n", + "3 -21182.0 -181.00 \n", + "4 0.0 -11668.14 \n", + "\n", + " nameDest-is Fraud step_1 step_10 ... step_5 step_6 step_7 step_8 \\\n", + "0 0.000000 1 0 ... 0 0 0 0 \n", + "1 0.000000 1 0 ... 0 0 0 0 \n", + "2 0.142857 1 0 ... 0 0 0 0 \n", + "3 0.200000 1 0 ... 0 0 0 0 \n", + "4 0.000000 1 0 ... 0 0 0 0 \n", + "\n", + " step_9 type_CASH_IN type_CASH_OUT type_DEBIT type_PAYMENT \\\n", + "0 0 0 0 0 1 \n", + "1 0 0 0 0 1 \n", + "2 0 0 0 0 0 \n", + "3 0 0 1 0 0 \n", + "4 0 0 0 0 1 \n", + "\n", + " type_TRANSFER \n", + "0 0 \n", + "1 0 \n", + "2 1 \n", + "3 0 \n", + "4 0 \n", + "\n", + "[5 rows x 23 columns]" + ] + }, + "execution_count": 606, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_dummy.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 607, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = data_dummy.drop(columns='isFraud')\n", + "y = data_dummy['isFraud']\n", + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.2, random_state=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 608, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "scaler = StandardScaler()\n", + "X_train_scaled = scaler.fit_transform(X_train)\n", + "X_test_scaled = scaler.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run a logisitc regression classifier and evaluate its accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 609, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "logreg = LogisticRegression(max_iter=1000)\n", + "logreg.fit(X_train_scaled, y_train)\n", + "\n", + "y_pred = logreg.predict(X_test_scaled)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 610, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 0.7894736842105263\n", + "recall: 0.6\n", + "confusion matrix :\n", + " [[19971 4]\n", + " [ 10 15]]\n" + ] + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "from sklearn.metrics import precision_score\n", + "from sklearn.metrics import recall_score\n", + "\n", + "print(\"precision: \",precision_score(y_test,y_pred))\n", + "print(\"recall: \",recall_score(y_test,y_pred))\n", + "print('confusion matrix :\\n', confusion_matrix(y_test,y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now pick a model of your choice and evaluate its accuracy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oversampling" + ] + }, + { + "cell_type": "code", + "execution_count": 611, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here\n", + "\n", + "from sklearn.utils import resample\n", + "\n", + "\n", + "y_train.reset_index(drop=True, inplace=True)\n", + "\n", + "\n", + "\n", + "X_train_scaled = pd.DataFrame(X_train_scaled, columns=X_train.columns)\n", + "X_train_scaled.reset_index(drop=True, inplace=True)\n", + "\n", + "\n", + "train = pd.concat([X_train_scaled, y_train], axis=1)\n", + "\n", + "not_fraud = train[train['isFraud']==0]\n", + "is_fraud = train[train['isFraud']==1]" + ] + }, + { + "cell_type": "code", + "execution_count": 612, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 79909\n", + "1 79909\n", + "Name: isFraud, dtype: int64" + ] + }, + "execution_count": 612, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oversampled = resample(is_fraud,\n", + " replace=True, # sample with replacement\n", + " n_samples=len(not_fraud), # match number in majority class\n", + " random_state=1)\n", + "\n", + "# Combine majority class with upsampled minority class\n", + "oversampled = pd.concat([not_fraud, oversampled])\n", + "\n", + "# Check the class distribution\n", + "oversampled['isFraud'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 613, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 0.23711340206185566\n", + "recall: 0.92\n", + "confusion matrix :\n", + " [[19901 74]\n", + " [ 2 23]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/bernaozer/anaconda3/lib/python3.11/site-packages/sklearn/base.py:465: UserWarning: X does not have valid feature names, but LogisticRegression was fitted with feature names\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "y_train_over = oversampled['isFraud'].copy()\n", + "X_train_over = oversampled.drop('isFraud',axis = 1).copy()\n", + "\n", + "logreg_over = LogisticRegression(max_iter=1000)\n", + "logreg_over.fit(X_train_over, y_train_over)\n", + "pred = logreg_over.predict(X_test_scaled)\n", + "\n", + "print(\"precision: \",precision_score(y_test,pred))\n", + "print(\"recall: \",recall_score(y_test,pred))\n", + "print('confusion matrix :\\n', confusion_matrix(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Undersampling" + ] + }, + { + "cell_type": "code", + "execution_count": 614, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1 91\n", + "0 91\n", + "Name: isFraud, dtype: int64" + ] + }, + "execution_count": 614, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "undersampled = resample(not_fraud,\n", + " replace=True, # sample with replacement\n", + " n_samples=len(is_fraud), # match number in majority class\n", + " random_state=1)\n", + "\n", + "\n", + "undersampled = pd.concat([is_fraud, undersampled])\n", + "\n", + "undersampled['isFraud'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 615, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 0.12437810945273632\n", + "recall: 1.0\n", + "confusion matrix :\n", + " [[19799 176]\n", + " [ 0 25]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/bernaozer/anaconda3/lib/python3.11/site-packages/sklearn/base.py:465: UserWarning: X does not have valid feature names, but LogisticRegression was fitted with feature names\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "y_train_under = undersampled['isFraud'].copy()\n", + "X_train_under = undersampled.drop('isFraud',axis = 1).copy()\n", + "\n", + "logreg_under = LogisticRegression()\n", + "logreg_under.fit(X_train_under, y_train_under)\n", + "pred = logreg_under.predict(X_test_scaled)\n", + "\n", + "print(\"precision: \",precision_score(y_test,pred))\n", + "print(\"recall: \",recall_score(y_test,pred))\n", + "print('confusion matrix :\\n', confusion_matrix(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DecisionTree Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 616, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 0.8333333333333334\n", + "recall: 0.8\n", + "confusion matrix :\n", + " [[19971 4]\n", + " [ 5 20]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/bernaozer/anaconda3/lib/python3.11/site-packages/sklearn/base.py:465: UserWarning: X does not have valid feature names, but DecisionTreeRegressor was fitted with feature names\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "from sklearn.tree import DecisionTreeRegressor\n", + "\n", + "tree_reg = DecisionTreeRegressor()\n", + "tree_reg = tree_reg .fit(X_train_scaled, y_train)\n", + "pred = tree_reg.predict(X_test_scaled)\n", + "\n", + "print(\"precision: \",precision_score(y_test,pred))\n", + "print(\"recall: \",recall_score(y_test,pred))\n", + "print('confusion matrix :\\n', confusion_matrix(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DecisionTree Regression with Oversampling" + ] + }, + { + "cell_type": "code", + "execution_count": 617, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 0.9090909090909091\n", + "recall: 0.8\n", + "confusion matrix :\n", + " [[19973 2]\n", + " [ 5 20]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/bernaozer/anaconda3/lib/python3.11/site-packages/sklearn/base.py:465: UserWarning: X does not have valid feature names, but DecisionTreeRegressor was fitted with feature names\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "tree_reg_over = DecisionTreeRegressor()\n", + "tree_reg_over = tree_reg_over.fit(X_train_over, y_train_over)\n", + "pred = tree_reg_over.predict(X_test_scaled)\n", + "\n", + "print(\"precision: \",precision_score(y_test,pred))\n", + "print(\"recall: \",recall_score(y_test,pred))\n", + "print('confusion matrix :\\n', confusion_matrix(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Which model worked better and how do you know?" + ] + }, + { + "cell_type": "code", + "execution_count": 618, + "metadata": {}, + "outputs": [], + "source": [ + "# Your response here\n", + "#After data engineering, I got the best precision and recall score with DecisionTree regression model with oversampling." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." + ] + } + ], + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}