From 723ca0ecb9ce711d80575400b3ad206720ddb149 Mon Sep 17 00:00:00 2001 From: Yuliya Lavrenyuk Date: Tue, 10 Sep 2024 10:00:59 +0200 Subject: [PATCH 1/2] Add .gitignore file --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..03b3a01 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.csv +*.zip From aa9abfac8cb34dcc3ff4673031a6c821a5528fd9 Mon Sep 17 00:00:00 2001 From: Yuliya Lavrenyuk Date: Tue, 10 Sep 2024 10:20:38 +0200 Subject: [PATCH 2/2] final_version --- your-code/lab_imbalance.ipynb | 2746 +++++++++++++++++++++++++++++++-- 1 file changed, 2599 insertions(+), 147 deletions(-) diff --git a/your-code/lab_imbalance.ipynb b/your-code/lab_imbalance.ipynb index dbb15e1..0e21837 100644 --- a/your-code/lab_imbalance.ipynb +++ b/your-code/lab_imbalance.ipynb @@ -1,147 +1,2599 @@ -{ - "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": "markdown", + "metadata": {}, + "source": [ + "### What is the distribution of the outcome? " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "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 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Your response here\n", + "import zipfile\n", + "\n", + "with zipfile.ZipFile(\"D:\\IronHack\\Study\\Bootcamp\\labs\\week 19\\lab-imbalance\\Fraud.csv.zip\",\"r\") as z:\n", + " z.extractall(\".\")\n", + "\n", + "import pandas as pd\n", + "\n", + "fraud = pd.read_csv(\"Fraud.csv\",nrows=100000)\n", + "display(fraud.head())" + ] + }, + { + "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": 2, + "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", + "fraud.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fraud.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "isFraud\n", + "0 99884\n", + "1 116\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fraud['isFraud'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Target is very imbalanced" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "dummies = pd.get_dummies(fraud['type'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
CASH_INCASH_OUTDEBITPAYMENTTRANSFER
0FalseFalseFalseTrueFalse
1FalseFalseFalseTrueFalse
2FalseFalseFalseFalseTrue
3FalseTrueFalseFalseFalse
4FalseFalseFalseTrueFalse
\n", + "
" + ], + "text/plain": [ + " CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER\n", + "0 False False False True False\n", + "1 False False False True False\n", + "2 False False False False True\n", + "3 False True False False False\n", + "4 False False False True False" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dummies.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
steptypeamountnameOrigoldbalanceOrgnewbalanceOrignameDestoldbalanceDestnewbalanceDestisFraudisFlaggedFraudCASH_INCASH_OUTDEBITPAYMENTTRANSFER
01PAYMENT9839.64C1231006815170136.0160296.36M19797871550.000.0000FalseFalseFalseTrueFalse
11PAYMENT1864.28C166654429521249.019384.72M20442822250.000.0000FalseFalseFalseTrueFalse
21TRANSFER181.00C1305486145181.00.00C5532640650.000.0010FalseFalseFalseFalseTrue
31CASH_OUT181.00C840083671181.00.00C3899701021182.000.0010FalseTrueFalseFalseFalse
41PAYMENT11668.14C204853772041554.029885.86M12307017030.000.0000FalseFalseFalseTrueFalse
...................................................
9999510PAYMENT4020.66C1410794718159929.0155908.34M12570365760.000.0000FalseFalseFalseTrueFalse
9999610PAYMENT18345.49C7443036776206.00.00M17853445560.000.0000FalseFalseFalseTrueFalse
9999710CASH_IN183774.91C10433185139173.0222947.91C3639288954925.050.0000TrueFalseFalseFalseFalse
9999810CASH_OUT82237.17C7076629666031.00.00C1553004158592635.66799140.4600FalseTrueFalseFalseFalse
9999910PAYMENT20096.56C1868032458110117.090020.44M14192018860.000.0000FalseFalseFalseTrueFalse
\n", + "

100000 rows × 16 columns

\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", + "99995 10 PAYMENT 4020.66 C1410794718 159929.0 155908.34 \n", + "99996 10 PAYMENT 18345.49 C744303677 6206.0 0.00 \n", + "99997 10 CASH_IN 183774.91 C104331851 39173.0 222947.91 \n", + "99998 10 CASH_OUT 82237.17 C707662966 6031.0 0.00 \n", + "99999 10 PAYMENT 20096.56 C1868032458 110117.0 90020.44 \n", + "\n", + " nameDest oldbalanceDest newbalanceDest isFraud isFlaggedFraud \\\n", + "0 M1979787155 0.00 0.00 0 0 \n", + "1 M2044282225 0.00 0.00 0 0 \n", + "2 C553264065 0.00 0.00 1 0 \n", + "3 C38997010 21182.00 0.00 1 0 \n", + "4 M1230701703 0.00 0.00 0 0 \n", + "... ... ... ... ... ... \n", + "99995 M1257036576 0.00 0.00 0 0 \n", + "99996 M1785344556 0.00 0.00 0 0 \n", + "99997 C36392889 54925.05 0.00 0 0 \n", + "99998 C1553004158 592635.66 799140.46 0 0 \n", + "99999 M1419201886 0.00 0.00 0 0 \n", + "\n", + " CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER \n", + "0 False False False True False \n", + "1 False False False True False \n", + "2 False False False False True \n", + "3 False True False False False \n", + "4 False False False True False \n", + "... ... ... ... ... ... \n", + "99995 False False False True False \n", + "99996 False False False True False \n", + "99997 True False False False False \n", + "99998 False True False False False \n", + "99999 False False False True False \n", + "\n", + "[100000 rows x 16 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fraud_with_dummies = pd.concat([fraud, dummies], axis=1)\n", + "\n", + "display(fraud_with_dummies)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nameOrig\n", + "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: count, Length: 100000, dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fraud_with_dummies['nameOrig'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nameDest\n", + "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: count, Length: 51551, dtype: int64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fraud_with_dummies['nameDest'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
steptypeamountnameOrigoldbalanceOrgnewbalanceOrignameDestoldbalanceDestnewbalanceDestisFraudisFlaggedFraudCASH_INCASH_OUTDEBITPAYMENTTRANSFER
01PAYMENT9839.6411862170136.0160296.36319810.000.0000FalseFalseFalseTrueFalse
11PAYMENT1864.283434521249.019384.72332880.000.0000FalseFalseFalseTrueFalse
21TRANSFER181.0015636181.00.0093030.000.0010FalseFalseFalseFalseTrue
31CASH_OUT181.0091777181.00.00827321182.000.0010FalseTrueFalseFalseFalse
41PAYMENT11668.145404141554.029885.86166810.000.0000FalseFalseFalseTrueFalse
...................................................
9999510PAYMENT4020.6621051159929.0155908.34172000.000.0000FalseFalseFalseTrueFalse
9999610PAYMENT18345.49866886206.00.00280110.000.0000FalseFalseFalseTrueFalse
9999710CASH_IN183774.91219839173.0222947.91811854925.050.0000TrueFalseFalseFalseFalse
9999810CASH_OUT82237.17847586031.00.003451592635.66799140.4600FalseTrueFalseFalseFalse
9999910PAYMENT20096.5644792110117.090020.44204680.000.0000FalseFalseFalseTrueFalse
\n", + "

100000 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " step type amount nameOrig oldbalanceOrg newbalanceOrig \\\n", + "0 1 PAYMENT 9839.64 11862 170136.0 160296.36 \n", + "1 1 PAYMENT 1864.28 34345 21249.0 19384.72 \n", + "2 1 TRANSFER 181.00 15636 181.0 0.00 \n", + "3 1 CASH_OUT 181.00 91777 181.0 0.00 \n", + "4 1 PAYMENT 11668.14 54041 41554.0 29885.86 \n", + "... ... ... ... ... ... ... \n", + "99995 10 PAYMENT 4020.66 21051 159929.0 155908.34 \n", + "99996 10 PAYMENT 18345.49 86688 6206.0 0.00 \n", + "99997 10 CASH_IN 183774.91 2198 39173.0 222947.91 \n", + "99998 10 CASH_OUT 82237.17 84758 6031.0 0.00 \n", + "99999 10 PAYMENT 20096.56 44792 110117.0 90020.44 \n", + "\n", + " nameDest oldbalanceDest newbalanceDest isFraud isFlaggedFraud \\\n", + "0 31981 0.00 0.00 0 0 \n", + "1 33288 0.00 0.00 0 0 \n", + "2 9303 0.00 0.00 1 0 \n", + "3 8273 21182.00 0.00 1 0 \n", + "4 16681 0.00 0.00 0 0 \n", + "... ... ... ... ... ... \n", + "99995 17200 0.00 0.00 0 0 \n", + "99996 28011 0.00 0.00 0 0 \n", + "99997 8118 54925.05 0.00 0 0 \n", + "99998 3451 592635.66 799140.46 0 0 \n", + "99999 20468 0.00 0.00 0 0 \n", + "\n", + " CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER \n", + "0 False False False True False \n", + "1 False False False True False \n", + "2 False False False False True \n", + "3 False True False False False \n", + "4 False False False True False \n", + "... ... ... ... ... ... \n", + "99995 False False False True False \n", + "99996 False False False True False \n", + "99997 True False False False False \n", + "99998 False True False False False \n", + "99999 False False False True False \n", + "\n", + "[100000 rows x 16 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "le=LabelEncoder()\n", + "fraud_with_dummies['nameOrig']=le.fit_transform(fraud_with_dummies['nameOrig'])\n", + "fraud_with_dummies['nameDest']=le.fit_transform(fraud_with_dummies['nameDest'])\n", + "\n", + "display(fraud_with_dummies)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "numeric_columns = fraud_with_dummies.select_dtypes(include=['int64', 'float64'])\n", + "\n", + "correlation_matrix = numeric_columns.corr()\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "sns.heatmap(correlation_matrix, annot=True, cmap='YlOrRd')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "fraud_with_dummies.drop(['oldbalanceOrg','oldbalanceDest','type','isFlaggedFraud'] ,axis =1, inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stepamountnameOrignewbalanceOrignameDestnewbalanceDestisFraudCASH_INCASH_OUTDEBITPAYMENTTRANSFER
019839.6411862160296.36319810.000FalseFalseFalseTrueFalse
111864.283434519384.72332880.000FalseFalseFalseTrueFalse
21181.00156360.0093030.001FalseFalseFalseFalseTrue
31181.00917770.0082730.001FalseTrueFalseFalseFalse
4111668.145404129885.86166810.000FalseFalseFalseTrueFalse
.......................................
99995104020.6621051155908.34172000.000FalseFalseFalseTrueFalse
999961018345.49866880.00280110.000FalseFalseFalseTrueFalse
9999710183774.912198222947.9181180.000TrueFalseFalseFalseFalse
999981082237.17847580.003451799140.460FalseTrueFalseFalseFalse
999991020096.564479290020.44204680.000FalseFalseFalseTrueFalse
\n", + "

100000 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " step amount nameOrig newbalanceOrig nameDest newbalanceDest \\\n", + "0 1 9839.64 11862 160296.36 31981 0.00 \n", + "1 1 1864.28 34345 19384.72 33288 0.00 \n", + "2 1 181.00 15636 0.00 9303 0.00 \n", + "3 1 181.00 91777 0.00 8273 0.00 \n", + "4 1 11668.14 54041 29885.86 16681 0.00 \n", + "... ... ... ... ... ... ... \n", + "99995 10 4020.66 21051 155908.34 17200 0.00 \n", + "99996 10 18345.49 86688 0.00 28011 0.00 \n", + "99997 10 183774.91 2198 222947.91 8118 0.00 \n", + "99998 10 82237.17 84758 0.00 3451 799140.46 \n", + "99999 10 20096.56 44792 90020.44 20468 0.00 \n", + "\n", + " isFraud CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER \n", + "0 0 False False False True False \n", + "1 0 False False False True False \n", + "2 1 False False False False True \n", + "3 1 False True False False False \n", + "4 0 False False False True False \n", + "... ... ... ... ... ... ... \n", + "99995 0 False False False True False \n", + "99996 0 False False False True False \n", + "99997 0 True False False False False \n", + "99998 0 False True False False False \n", + "99999 0 False False False True False \n", + "\n", + "[100000 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(fraud_with_dummies)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "X = fraud_with_dummies.drop('isFraud', axis=1) \n", + "y = fraud_with_dummies['isFraud']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run a logisitc regression classifier and evaluate its accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.2, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "model = LogisticRegression()\n", + "model = model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9989" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "\n", + "pred = model.predict(X_test)\n", + "accuracy_score(y_test,pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[19978, 0],\n", + " [ 22, 0]], dtype=int64)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "confusion_matrix(y_test,pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 19978\n", + " 1 0.00 0.00 0.00 22\n", + "\n", + " accuracy 1.00 20000\n", + " macro avg 0.50 0.50 0.50 20000\n", + "weighted avg 1.00 1.00 1.00 20000\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1509: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1509: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1509: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report\n", + "print(classification_report(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model has a perfect accuracy of 1.00, but this is misleading because the dataset is highly imbalanced. The model is simply predicting the majority class (class 0) almost all the time.\n", + "Failure to Identify Fraud (class 1): The model fails to correctly identify any instance of class 1 (fraud). This is evident from the 0 precision, recall, and F1-score for class 1.\n", + "Imbalance Issue: This suggests that the model is heavily biased towards the majority class (class 0) and is not effective at detecting fraud (class 1). In real-world applications like fraud detection, such a model would be inadequate because it would miss all fraudulent cases." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now pick a model of your choice and evaluate its accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here\n", + "#Let's try to do oversampling :\n", + "\n", + "fraud = fraud_with_dummies[fraud_with_dummies['isFraud'] ==1]\n", + "no_fraud = fraud_with_dummies[fraud_with_dummies['isFraud'] == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(116, 12)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(99884, 12)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(fraud.shape)\n", + "display(no_fraud.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.utils import resample" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# oversample minority\n", + "yes_fraud_oversampled = resample(fraud, #<- sample from here\n", + " replace=True, #<- we need replacement, since we don't have enough data otherwise\n", + " n_samples = len(no_fraud),#<- make both sets the same size\n", + " random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "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", + "
stepamountnameOrignewbalanceOrignameDestnewbalanceDestisFraudCASH_INCASH_OUTDEBITPAYMENTTRANSFER
019839.6411862160296.36319810.00FalseFalseFalseTrueFalse
111864.283434519384.72332880.00FalseFalseFalseTrueFalse
4111668.145404129885.86166810.00FalseFalseFalseTrueFalse
517817.719481946042.29427270.00FalseFalseFalseTrueFalse
617107.7728265176087.23393430.00FalseFalseFalseTrueFalse
\n", + "
" + ], + "text/plain": [ + " step amount nameOrig newbalanceOrig nameDest newbalanceDest \\\n", + "0 1 9839.64 11862 160296.36 31981 0.0 \n", + "1 1 1864.28 34345 19384.72 33288 0.0 \n", + "4 1 11668.14 54041 29885.86 16681 0.0 \n", + "5 1 7817.71 94819 46042.29 42727 0.0 \n", + "6 1 7107.77 28265 176087.23 39343 0.0 \n", + "\n", + " isFraud CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER \n", + "0 0 False False False True False \n", + "1 0 False False False True False \n", + "4 0 False False False True False \n", + "5 0 False False False True False \n", + "6 0 False False False True False " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_oversampled = pd.concat([no_fraud,yes_fraud_oversampled])\n", + "train_oversampled.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(199768, 12)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_oversampled.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "y_train_over = train_oversampled['isFraud'].copy()\n", + "X_train_over = train_oversampled.drop('isFraud',axis = 1).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "LR = LogisticRegression(max_iter=1000)\n", + "LR.fit(X_train_over, y_train_over)\n", + "pred = LR.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[16992, 2986],\n", + " [ 1, 21]], dtype=int64)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(y_test,pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.85 0.92 19978\n", + " 1 0.01 0.95 0.01 22\n", + "\n", + " accuracy 0.85 20000\n", + " macro avg 0.50 0.90 0.47 20000\n", + "weighted avg 1.00 0.85 0.92 20000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lower Accuracy: The accuracy is 0.85, which is lower than the first model. However, this model is significantly better at identifying fraud (class 1).\n", + "Recall (0.96 for class 1): This model successfully identifies 96% of actual fraud cases. The model's recall for class 1 (fraud) is significantly higher, meaning it is much better at catching fraudulent transactions.\n", + "Precision (0.01 for class 1): The precision for class 1 is low (0.01), indicating that when the model predicts a transaction as fraudulent, it is often incorrect. However, in fraud detection, a higher recall is generally more important because missing fraudulent transactions (low recall) can be very costly.\n", + "F1-Score (0.01 for class 1): The F1-score for class 1 is low, reflecting the trade-off between precision and recall. However, the high recall suggests that this model is much more useful in scenarios where identifying fraud is critical." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "#Undersampling:\n", + "# undersample majority\n", + "no_fraud_undersampled = resample(no_fraud, #<- downsample from here\n", + " replace=False, #<- no need to reuse data now, we have an abundance\n", + " n_samples = len(fraud),\n", + " random_state=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(116, 12)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(116, 12)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(fraud.shape)\n", + "display(no_fraud_undersampled.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "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", + "
stepamountnameOrignewbalanceOrignameDestnewbalanceDestisFraudCASH_INCASH_OUTDEBITPAYMENTTRANSFER
21181.0156360.093030.01FalseFalseFalseFalseTrue
31181.0917770.082730.01FalseTrueFalseFalseFalse
25112806.0215810.0118640.01FalseFalseFalseFalseTrue
25212806.0568330.0530.01FalseTrueFalseFalseFalse
680120128.0192510.053250.01FalseFalseFalseFalseTrue
\n", + "
" + ], + "text/plain": [ + " step amount nameOrig newbalanceOrig nameDest newbalanceDest \\\n", + "2 1 181.0 15636 0.0 9303 0.0 \n", + "3 1 181.0 91777 0.0 8273 0.0 \n", + "251 1 2806.0 21581 0.0 11864 0.0 \n", + "252 1 2806.0 56833 0.0 53 0.0 \n", + "680 1 20128.0 19251 0.0 5325 0.0 \n", + "\n", + " isFraud CASH_IN CASH_OUT DEBIT PAYMENT TRANSFER \n", + "2 1 False False False False True \n", + "3 1 False True False False False \n", + "251 1 False False False False True \n", + "252 1 False True False False False \n", + "680 1 False False False False True " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_undersampled = pd.concat([fraud,no_fraud_undersampled])\n", + "train_undersampled.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "y_train_under = train_undersampled['isFraud'].copy()\n", + "X_train_under = train_undersampled.drop('isFraud',axis = 1).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "LR = LogisticRegression(max_iter=1000)\n", + "LR.fit(X_train_under, y_train_under)\n", + "pred = LR.predict(X_test)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[16854, 3124],\n", + " [ 1, 21]], dtype=int64)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(y_test,pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.84 0.92 19978\n", + " 1 0.01 0.95 0.01 22\n", + "\n", + " accuracy 0.84 20000\n", + " macro avg 0.50 0.90 0.46 20000\n", + "weighted avg 1.00 0.84 0.91 20000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "#Using SMOTE\n", + "from imblearn.over_sampling import SMOTE" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "sm = SMOTE(random_state = 42,sampling_strategy=1.0)\n", + "X_train_SMOTE,y_train_SMOTE = sm.fit_resample(X_train,y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "LR = LogisticRegression(max_iter=1000)\n", + "LR.fit(X_train_SMOTE, y_train_SMOTE)\n", + "pred = LR.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[18559, 1419],\n", + " [ 1, 21]], dtype=int64)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(y_test,pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.93 0.96 19978\n", + " 1 0.01 0.95 0.03 22\n", + "\n", + " accuracy 0.93 20000\n", + " macro avg 0.51 0.94 0.50 20000\n", + "weighted avg 1.00 0.93 0.96 20000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "SMOTE with another models:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Forest Classifier with SMOTE\n", + "[[19939 39]\n", + " [ 13 9]]\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 19978\n", + " 1 0.19 0.41 0.26 22\n", + "\n", + " accuracy 1.00 20000\n", + " macro avg 0.59 0.70 0.63 20000\n", + "weighted avg 1.00 1.00 1.00 20000\n", + "\n" + ] + } + ], + "source": [ + "classifier = RandomForestClassifier(random_state=42)\n", + "classifier.fit(X_train_SMOTE, y_train_SMOTE)\n", + "\n", + "\n", + "y_pred = classifier.predict(X_test)\n", + "\n", + "print(\"Random Forest Classifier with SMOTE\")\n", + "print(confusion_matrix(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "from xgboost import XGBClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\xgboost\\core.py:158: UserWarning: [10:06:03] WARNING: C:\\buildkite-agent\\builds\\buildkite-windows-cpu-autoscaling-group-i-0015a694724fa8361-1\\xgboost\\xgboost-ci-windows\\src\\learner.cc:740: \n", + "Parameters: { \"use_label_encoder\" } are not used.\n", + "\n", + " warnings.warn(smsg, UserWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "XGBoost Classifier with SMOTE\n", + "[[19861 117]\n", + " [ 12 10]]\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.99 1.00 19978\n", + " 1 0.08 0.45 0.13 22\n", + "\n", + " accuracy 0.99 20000\n", + " macro avg 0.54 0.72 0.57 20000\n", + "weighted avg 1.00 0.99 1.00 20000\n", + "\n" + ] + } + ], + "source": [ + "xgb_model = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42)\n", + "xgb_model.fit(X_train_SMOTE, y_train_SMOTE)\n", + "\n", + "# Step 3: Predict on the test data\n", + "y_pred = xgb_model.predict(X_test)\n", + "\n", + "# Step 4: Evaluate the model\n", + "print(\"XGBoost Classifier with SMOTE\")\n", + "print(confusion_matrix(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can try to use grid search and improve accuracy:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import GridSearchCV" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 108 candidates, totalling 324 fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\xgboost\\core.py:158: UserWarning: [10:17:22] WARNING: C:\\buildkite-agent\\builds\\buildkite-windows-cpu-autoscaling-group-i-0015a694724fa8361-1\\xgboost\\xgboost-ci-windows\\src\\learner.cc:740: \n", + "Parameters: { \"use_label_encoder\" } are not used.\n", + "\n", + " warnings.warn(smsg, UserWarning)\n" + ] + } + ], + "source": [ + "param_grid = {\n", + " 'max_depth': [3, 5, 7],\n", + " 'learning_rate': [0.01, 0.1, 0.2],\n", + " 'n_estimators': [100, 200, 500],\n", + " 'subsample': [0.8, 1.0],\n", + " 'colsample_bytree': [0.8, 1.0],\n", + "}\n", + "\n", + "grid_search = GridSearchCV(estimator=XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42),\n", + " param_grid=param_grid, \n", + " scoring='f1', \n", + " cv=3, \n", + " verbose=1, \n", + " n_jobs=-1)\n", + "\n", + "grid_search.fit(X_train_SMOTE, y_train_SMOTE)\n", + "\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "# # Predict and evaluate with the best model\n", + "# y_pred = best_model.predict(X_test)\n", + "# print(confusion_matrix(y_test, y_pred))\n", + "# print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'colsample_bytree': 1.0,\n", + " 'learning_rate': 0.2,\n", + " 'max_depth': 7,\n", + " 'n_estimators': 500,\n", + " 'subsample': 0.8}" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.best_params_" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Yuliya Lavrenyuk\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\xgboost\\core.py:158: UserWarning: [10:17:36] WARNING: C:\\buildkite-agent\\builds\\buildkite-windows-cpu-autoscaling-group-i-0015a694724fa8361-1\\xgboost\\xgboost-ci-windows\\src\\learner.cc:740: \n", + "Parameters: { \"use_label_encoder\" } are not used.\n", + "\n", + " warnings.warn(smsg, UserWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "XGBoost Classifier with SMOTE\n", + "[[19908 70]\n", + " [ 13 9]]\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 19978\n", + " 1 0.11 0.41 0.18 22\n", + "\n", + " accuracy 1.00 20000\n", + " macro avg 0.56 0.70 0.59 20000\n", + "weighted avg 1.00 1.00 1.00 20000\n", + "\n" + ] + } + ], + "source": [ + "xgb_model = XGBClassifier(use_label_encoder=True, eval_metric='logloss', random_state=42, colsample_bytree = 1.0,\n", + " learning_rate=0.2,\n", + " max_depth= 7,\n", + " n_estimators= 500,\n", + " subsample=0.8)\n", + "\n", + "xgb_model.fit(X_train_SMOTE, y_train_SMOTE)\n", + "\n", + "# Step 3: Predict on the test data\n", + "y_pred = xgb_model.predict(X_test)\n", + "\n", + "# Step 4: Evaluate the model\n", + "print(\"XGBoost Classifier with SMOTE\")\n", + "print(confusion_matrix(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Which model worked better and how do you know?" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "unterminated string literal (detected at line 7) (2272469407.py, line 7)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Cell \u001b[1;32mIn[52], line 7\u001b[1;36m\u001b[0m\n\u001b[1;33m Model Complexity: XGBoost is more complex than linear classifiers, which means it might require more careful tuning of hyperparameters, particularly with imbalanced data. If the model isn't well-tuned, it can perform worse than simpler models.\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m unterminated string literal (detected at line 7)\n" + ] + } + ], + "source": [ + "# Your response here\n", + "In my results, it seems that the XGBoost model and RF, despite being a more sophisticated and powerful models, are performing worse than a linear classifier.\n", + "This may happen for several reasons:\n", + "\n", + "Overfitting: XGBoost is a highly flexible model with many hyperparameters. Without careful tuning, it can easily overfit to the training data, especially when using techniques like SMOTE, which can sometimes introduce noise by generating synthetic data points.\n", + "\n", + "Model Complexity: XGBoost is more complex than linear classifiers, which means it might require more careful tuning of hyperparameters, particularly with imbalanced data. If the model isn't well-tuned, it can perform worse than simpler models.\n", + "\n", + "Data Quality: The quality and characteristics of the data after applying SMOTE can sometimes degrade the performance of more complex models. SMOTE generates synthetic samples, which might not always perfectly represent real data, especially in high-dimensional spaces.\n", + "\n", + "Class Imbalance: Even with SMOTE, if the classes are still imbalanced, it could cause issues. Additionally, SMOTE sometimes introduces synthetic points that might not align well with the decision boundaries needed by more complex models like XGBoost.\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." + ] + } + ], + "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.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}