diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b5c8e95 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ + +consumer_complaints.csv +.DS_Store diff --git a/generate_report.py b/generate_report.py new file mode 100644 index 0000000..8934a52 --- /dev/null +++ b/generate_report.py @@ -0,0 +1,194 @@ +from fpdf import FPDF + +pdf = FPDF() +WIDTH = 210 +HEIGHT = 297 +X = 0 +Y = 0 + +def set_letterhead(pdf: FPDF = pdf): + pdf.image("./resources/letterhead.png", -1, 0, WIDTH*1.1, HEIGHT*1.18) + pass + +def set_title_font(pdf: FPDF = pdf): + pdf.set_font('Arial', 'B', 22) + +def set_heading_1_font(pdf: FPDF = pdf): + pdf.set_font('Arial', 'B', 18) + +def set_heading_2_font(pdf: FPDF = pdf): + pdf.set_font('Arial', 'I', 14) + +def set_p_font(pdf: FPDF = pdf): + pdf.set_font('Arial', '', 11) + +def set_p_i_font(pdf: FPDF = pdf): + pdf.set_font('Arial', 'I', 11) + +def lb(size: float = 10): + global Y + Y += size + pdf.ln(size) + + +### PAGE 1 +pdf.add_page() + +# Letterhead +set_letterhead() + +# Title of report +set_title_font() +lb(12) +pdf.write(5, f"Consumer Financial Complaints Report") +lb(8) + +set_heading_2_font() +pdf.write(5, "Anuj Singla") +lb(7) + +set_p_font() +pdf.write(5, "September 28th, 2022") +lb(15) + +# Introduction +set_heading_1_font() +pdf.write(10, "Introduction") +lb() + +set_p_font() +pdf.write(5, ("As a new financial institution entering alpha, our mission is to optimize " + "the efficiency of every facet of our operations. Consumer complaints are " + "inevitable, but handling disputed resolutions can often become a costly and " + "time-consuming process. It is in our best interest to examine our clients' " + "backgrounds and prevent them from disputing claims by offering them sufficient " + "initial resolutions.")) +lb(15) + +# Data +set_heading_1_font() +pdf.write(10, "Data") +lb() + +# Data visualization 1 +set_heading_2_font() +pdf.write(10, "1) How does product affect dispute rate?") +lb(35) + +image_width = WIDTH / 1.1 # Make image fit comfortbly on the page +image_height = WIDTH / (1.1 * 1132 / 525) # Set height proportional to width and original pixel dimensions +pdf.image("./resources/visualizations/product-disputes.png", 7, Y, image_width, image_height) +lb(image_height / 1.4) + +set_p_font() +pdf.write(5,"Mortgages are the most frequent complaint product and have the highest rate of disputes. " + "On the other hand, although credit reporting has a fairly large amount of complaints " + "(~15,000), it has a lower rate of disputes compared to the rest of the products.") +lb(6) +set_p_i_font() +pdf.write(6, " - Why are mortgages disputed so frequently?\n" + " - Why is credit reporting disputed so rarely?\n" + " - Why do mortgages have over twice the amount of complaints as any other product?") + + +### PAGE 2 +pdf.add_page() +Y = 0 + +# Letterhead +set_letterhead() + +# Data visualization 2 +set_heading_2_font() +pdf.write(10, "2) How does location affect dispute rate?") +lb(20) + +pdf.image("./resources/visualizations/state-disputes.png", 7, Y, image_width, image_height) +lb(image_height / 1.3) + +set_p_font() +pdf.write(5, "Consumers in the west coast seem to be more likely to dispute their " + "complaint resolutions compared to the rest of the country, followed " + "by the east coast. The middle region of the country, highlighted by " + "New Mexico and South Dakota, have much lower dispute rates.") +lb(6) +set_p_i_font() +pdf.write(6, " - Why does the west coast dispute their complaints so frequently?\n" + " - Why does the plains region generally have such low dispute rates?") +lb(15) + +# Data visualization 3 +set_heading_2_font() +pdf.write(10, "3) How does complaint submission method affect dispute rate?") +lb(35) + +pdf.image("./resources/visualizations/submission-disputes.png", 7, Y, image_width, image_height) +lb(image_height / 1.5) + +set_p_font() +pdf.write(5, "Web submissions, which also happen to be the most common form of complaint " + "submission, have the highest dispute rate. On the other hand, postal mail " + "submissions, which are one of the least common methods for complaint submissions, " + "have the lowest dispute rates. Most notably, instant and non-verbal forms " + "of communication (web, fax, email) have higher dispute rates than slower, " + "non-anonymous methods of submission (referral, phone, postal mail).") +lb(6) +set_p_i_font() +pdf.write(6, " - Do time-consuming submission methods create a barrier for consumers to dispute?") + + +### PAGE 3 +pdf.add_page() +Y = 0 + +# Letterhead +set_letterhead() + +# Data visualization 3 +set_heading_2_font() +pdf.write(10, "4) Sentiment analysis on the most common issues") +lb(25) + +image_width /= 2.15 +image_height /= 2.15 + +pdf.image("./resources/visualizations/all-complaints-wc.png", 10, Y, image_width, image_height) +pdf.image("./resources/visualizations/disputed-complaints-wc.png", 20+image_width, Y, image_width, image_height) +lb(image_height / 1.4) + +set_p_i_font() +pdf.cell(w=image_width, h=6, txt='WordCloud of All Issues', align='C') +pdf.cell(w=image_width/9, h=6, txt='', align='C') +pdf.cell(w=image_width, h=6, txt='WordCloud of Disputed Issues Only', align='C') +lb(10) + +set_p_font() +pdf.write(5, "A form of modification (loan, collection) is the most common issue found " +"in sentiment analysis. Credit reports seem to be less common among disputes than all " +"issues. However, servicing payments seems to be an issue that leads to greater disputes.") +lb(6) + +set_p_i_font() +pdf.write(6, " - Why is servicing payments more common among disputed issues?\n" + " - Why are credit reports less common among disputed issues?\n" + " - What makes loan and collection modification such common issues?") +lb(15) + +# Introduction +set_heading_1_font() +pdf.write(10, "Conclusion") +lb() + +set_p_font() +pdf.write(5, "Further research and exploration is required to make any concrete conclusions. " + "However, these current data insights can orient us in the right direction." + "We must gather more data to answer the questions generated from such visualiaitons, " + "and in doing so, generate quality financial complaint resolutions for our consumers.") +lb() + +set_p_i_font() +pdf.write(5, "Note: Future hypotheses are located in the GitHub LaTeX file.") + + +### EXPORT REPORT AS PDF +pdf.output('report.pdf') \ No newline at end of file diff --git a/hypotheses.tex b/hypotheses.tex new file mode 100644 index 0000000..a84e8c4 --- /dev/null +++ b/hypotheses.tex @@ -0,0 +1,43 @@ +\documentclass{report} +\usepackage[utf8]{inputenc} + +\title{Financial Complaints Project Future Hypotheses} +\author{Anuj Singla} +\date{September 29th, 2022} + +\setcounter{secnumdepth}{3} + +\begin{document} + +\maketitle + +\chapter{Current Project} + +\section{Optimizing the ML Model} +Only one scikit-learn Logistic Regression model was used and was biased toward classifying a complaint in the "non-dispute" category. +\subsection{If an ensemble method such as XGBoost is optimized for the data set, then the model will make less biased predictions than the Logistic Regression model.} +\subsection{If the data is balanced to include less non-disputes, then the ML classifier will train with less bias.} +\subsection{If stronger feature analysis and engineering is performed on the data set, then the ML model will have greater performance with respect to consumer disputes.} + +\section{Data Insights} +The following features were compared to consumer disputes: product, state, submission method, and issue. +\subsection{If a product is more commonly used within a financial institution, then it will have more complaints.} +\subsection{If a consumer is located in a state on the western coast of the United States, then they are more likely to dispute their resolution.} +\subsection{If a consumer uses an online method of submitting their complaint, then they are more likely to dispute their resolution.} +\subsection{If a consumer submits an issue for servicing payments, then they are more likely to dispute their resolution.} + +\section{Additional Dispute Prediction Project Implementations} +\subsection{If sentiment analysis on issues is used as a feature in the ML Model, then the classifier will have stronger performance.} +\subsection{If dimensionality reduction with principal component analysis (PCA) is used, then strong, new visualizations and insights can be drawn from the data.} + + +\chapter{Additional Ideas} + +\section{Data Exploration} +\subsection{Interactive map that highlights different zip codes and their attributes.} +\subsection{Advanced sentiment analysis on product, sub-product, issue, and sub-issue.} + +\section{ML Prediction} +\subsection{Predicting how the company will resolve the complaint} + +\end{document} diff --git a/main.ipynb b/main.ipynb new file mode 100644 index 0000000..81e7e0f --- /dev/null +++ b/main.ipynb @@ -0,0 +1,1568 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Note: To see plotly data visualizations, please copy the GitHub file path and run in nbviewer.org\n", + "**Link: nbviewer.org/github/anujs1/data-oa/blob/main/main.ipynb**\n", + "\n", + "**If the above link doesn't work, try: https://nbviewer.org/github/anujs1/data-oa/blob/testing/main.ipynb**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, I examine how we can use financial complaints to predict whether a consumer will dispute their resolution. Disputes can often be a time-consuming and expensive process with high opportunity costs, and building a model to predict when these disputes may occur will help financial institutions offer their best resolution in their first try and therefore save resources." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Initialize and Clean Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import libraries and disable warnings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install xgboost\n", + "%pip install plotly\n", + "%pip install wordcloud\n", + "\n", + "import plotly.express as px\n", + "import plotly.io as pio\n", + "import wordcloud as cloud\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "import xgboost as xgb\n", + "from sklearn.model_selection import train_test_split, StratifiedShuffleSplit\n", + "from sklearn.metrics import accuracy_score, plot_confusion_matrix, classification_report\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "pio.renderers.default = 'notebook_connected'\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import data and view first five rows" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + "
date_receivedproductsub_productissuesub_issueconsumer_complaint_narrativecompany_public_responsecompanystatezipcodetagsconsumer_consent_providedsubmitted_viadate_sent_to_companycompany_response_to_consumertimely_responseconsumer_disputed?complaint_id
02013-08-30MortgageOther mortgageLoan modification,collection,foreclosureNaNNaNNaNU.S. BancorpCA95993NaNNaNReferral2013-09-03Closed with explanationYesYes511074
12013-08-30MortgageOther mortgageLoan servicing, payments, escrow accountNaNNaNNaNWells Fargo & CompanyCA91104NaNNaNReferral2013-09-03Closed with explanationYesYes511080
22013-08-30Credit reportingNaNIncorrect information on credit reportAccount statusNaNNaNWells Fargo & CompanyNY11764NaNNaNPostal mail2013-09-18Closed with explanationYesNo510473
32013-08-30Student loanNon-federal student loanRepaying your loanRepaying your loanNaNNaNNavient Solutions, Inc.MD21402NaNNaNEmail2013-08-30Closed with explanationYesYes510326
42013-08-30Debt collectionCredit cardFalse statements or representationAttempted to collect wrong amountNaNNaNResurgent Capital Services L.P.GA30106NaNNaNWeb2013-08-30Closed with explanationYesYes511067
\n", + "
" + ], + "text/plain": [ + " date_received product sub_product \\\n", + "0 2013-08-30 Mortgage Other mortgage \n", + "1 2013-08-30 Mortgage Other mortgage \n", + "2 2013-08-30 Credit reporting NaN \n", + "3 2013-08-30 Student loan Non-federal student loan \n", + "4 2013-08-30 Debt collection Credit card \n", + "\n", + " issue \\\n", + "0 Loan modification,collection,foreclosure \n", + "1 Loan servicing, payments, escrow account \n", + "2 Incorrect information on credit report \n", + "3 Repaying your loan \n", + "4 False statements or representation \n", + "\n", + " sub_issue consumer_complaint_narrative \\\n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 Account status NaN \n", + "3 Repaying your loan NaN \n", + "4 Attempted to collect wrong amount NaN \n", + "\n", + " company_public_response company state zipcode tags \\\n", + "0 NaN U.S. Bancorp CA 95993 NaN \n", + "1 NaN Wells Fargo & Company CA 91104 NaN \n", + "2 NaN Wells Fargo & Company NY 11764 NaN \n", + "3 NaN Navient Solutions, Inc. MD 21402 NaN \n", + "4 NaN Resurgent Capital Services L.P. GA 30106 NaN \n", + "\n", + " consumer_consent_provided submitted_via date_sent_to_company \\\n", + "0 NaN Referral 2013-09-03 \n", + "1 NaN Referral 2013-09-03 \n", + "2 NaN Postal mail 2013-09-18 \n", + "3 NaN Email 2013-08-30 \n", + "4 NaN Web 2013-08-30 \n", + "\n", + " company_response_to_consumer timely_response consumer_disputed? \\\n", + "0 Closed with explanation Yes Yes \n", + "1 Closed with explanation Yes Yes \n", + "2 Closed with explanation Yes No \n", + "3 Closed with explanation Yes Yes \n", + "4 Closed with explanation Yes Yes \n", + "\n", + " complaint_id \n", + "0 511074 \n", + "1 511080 \n", + "2 510473 \n", + "3 510326 \n", + "4 511067 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv('consumer_complaints.csv', parse_dates = ['date_received', 'date_sent_to_company'], low_memory = False)\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before generating any insights, it is important to clean the data of any information that may hinder visualizations or conclusions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "View the amount of empty rows for each individual column. Which features are too sparse to generate strong insights into consumer disptues?" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date_received 0\n", + "product 0\n", + "sub_product 158322\n", + "issue 0\n", + "sub_issue 343335\n", + "consumer_complaint_narrative 489151\n", + "company_public_response 470833\n", + "company 0\n", + "state 4887\n", + "zipcode 4505\n", + "tags 477998\n", + "consumer_consent_provided 432499\n", + "submitted_via 0\n", + "date_sent_to_company 0\n", + "company_response_to_consumer 0\n", + "timely_response 0\n", + "consumer_disputed? 0\n", + "complaint_id 0\n", + "dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some zipcodes are improperly formatted, such as '95XXX', and cannot be converted to integers. Replace these zipcodes with NaN, so that the entire column can be treated as a numerical feature and the true number of missing values are accounted for." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 82069 improperly formatted or NaN zipcodes\n" + ] + } + ], + "source": [ + "faulty_zipcodes = 0\n", + "for i in range(len(df['zipcode'])):\n", + " try:\n", + " int(df['zipcode'][i])\n", + " except:\n", + " faulty_zipcodes += 1 # Increment counter for improperly formatted zipcodes\n", + " df['zipcode'][i] = np.NaN # Set the improperly formatted zipcode to NaN\n", + "\n", + "print(f\"There are {faulty_zipcodes} improperly formatted or NaN zipcodes\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find the features consisting of more than 10% NaN values. I set 10% to be our NaN threshold, as any more could lead to improperly imputed data that harms our insights and model performance." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sub_product 0.284774\n", + "sub_issue 0.617557\n", + "consumer_complaint_narrative 0.879836\n", + "company_public_response 0.846887\n", + "zipcode 0.147618\n", + "tags 0.859775\n", + "consumer_consent_provided 0.777936\n", + "dtype: float64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "drop_threshold = 0.10\n", + "cols_na_counts = df.isna().mean(axis=0) # Get the NaN counts for each column\n", + "cols_over_dt = cols_na_counts[cols_na_counts >= drop_threshold] # Filter the columns to only include those with > 10% NaN\n", + "cols_over_dt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Drop features and reformat categorical features into numerical features so that they can be interpreted by a classification model.\n", + "\n", + "Drops due to unhelpfulness (if we use the ML model for our institution, these categories are either unhelpful or will create data leakage):\n", + "* complaint_id\n", + "* company\n", + "\n", + "Drops due to high NaN counts (> 10%):\n", + "* sub_product\n", + "* sub_issue\n", + "* consumer_complaint_narrative\n", + "* company_public_response\n", + "* zipcode\n", + "* tags\n", + "* consumer_consent_provided\n", + "\n", + "Data reformatted:\n", + "* Yes/No columns converted from str to int: 'No' -> 0 and 'Yes' -> 1\n", + "* company_response_to_consumer converted from str to int: 'Closed' -> 1, otherwise str -> 0\n", + "* date_received and date_sent_to_company converted from DateTime to int as its ordinal value" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Drop data\n", + "col_drops = list(cols_over_dt.index) + ['company', 'complaint_id']\n", + "df = df.drop(col_drops, axis=1)\n", + "\n", + "# Reformat data\n", + "df = df.replace(['Yes', 'No'], [1, 0])\n", + "\n", + "# Change all types of closed cases to 1, unclosed cases to 0 (converts to numerical feature)\n", + "case_col = 'company_response_to_consumer'\n", + "df.loc[df[case_col].str.contains('Closed'), case_col] = 1\n", + "df.loc[df[case_col] != 1, case_col] = 0\n", + "\n", + "# Change all datetime objects to ordinal value of date (converts to numerical feature)\n", + "date_cols = ['date_received', 'date_sent_to_company']\n", + "for date_col in date_cols:\n", + " df[date_col] = df[date_col].apply(pd.Timestamp.toordinal)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Drop NaN rows for state column" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date_received 0\n", + "product 0\n", + "issue 0\n", + "state 0\n", + "submitted_via 0\n", + "date_sent_to_company 0\n", + "company_response_to_consumer 0\n", + "timely_response 0\n", + "consumer_disputed? 0\n", + "dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = df.dropna(subset=['state'])\n", + "df.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Functions to create a new DataFrame containing the frequency values of a given feature, as well as the proportion of a given feature that was disputed. I created these functions to be modular and able to generate a DataFrame for any feature. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dispute_category = ''\n", + "# Returns a new 'consumer_disputed?' column with the count of a given category that was disputed\n", + "def get_disputes(row):\n", + " return df[(df['consumer_disputed?'] == 1) & (df[dispute_category] == row[dispute_category])]['consumer_disputed?'].sum()\n", + "\n", + "# Returns a new DataFrame with the count of a given category that was disputed and not disputed in separate rows\n", + "def get_frequency_df(dispute_category: str, data: pd.DataFrame = df) -> pd.DataFrame:\n", + " cat_df = data[[dispute_category, 'issue', 'consumer_disputed?']].groupby([dispute_category]).count().reset_index()\n", + " cat_df['consumer_disputed?'] = cat_df.apply(get_disputes, axis=1)\n", + " cat_df['percent_disputes'] = cat_df.apply(lambda row: (row['consumer_disputed?'] / row['issue']) * 100, axis=1)\n", + " return cat_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a scatterplot to frequency and dispute rate of each product" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dispute_category = 'product'\n", + "product_df = get_frequency_df(dispute_category)\n", + "\n", + "fig = px.scatter(\n", + " product_df,\n", + " x='consumer_disputed?',\n", + " y='percent_disputes',\n", + " size='issue',\n", + " color=dispute_category,\n", + " title='Product vs Consumer Disputes',\n", + " labels={\n", + " 'consumer_disputed?': 'Consumer Disputes',\n", + " 'percent_disputes': 'Percent of Complaints Disputed',\n", + " 'product': 'Product',\n", + " 'issue': 'Total Complaints',\n", + " },\n", + " range_x=[0, 45000],\n", + " hover_name='product',\n", + ")\n", + "fig.show('notebook_connected')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It appears that mortgages are the most frequent complaint product, AND have the highest rate of disputes. On the other hand, although credit reporting has a fair amount of complaints (~15,000), it has a low rate of disputes compared to the rest of the products." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a cloropleth to visualize the states with the highest rates of disputed claims" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dispute_category = 'state'\n", + "\n", + "state_abbr = [\n", + " 'AK', 'AL', 'AR', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'FL', 'GA',\n", + " 'HI', 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME',\n", + " 'MI', 'MN', 'MO', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM',\n", + " 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX',\n", + " 'UT', 'VA', 'VT', 'WA', 'WI', 'WV', 'WY'\n", + "]\n", + "\n", + "# Filter the data set to only include US states\n", + "usa_df = df[df[dispute_category].isin(state_abbr)][[dispute_category, 'issue', 'consumer_disputed?']]\n", + "usa_df = get_frequency_df(dispute_category, usa_df)\n", + "\n", + "fig = px.choropleth(\n", + " usa_df,\n", + " locations=dispute_category,\n", + " locationmode=\"USA-states\",\n", + " scope=\"usa\",\n", + " color='percent_disputes',\n", + " color_continuous_scale=\"rdylgn_r\",\n", + " title='State vs Percentage of Consumer Disputes',\n", + " labels={\n", + " 'consumer_disputed?': 'Consumer Disputes',\n", + " 'percent_disputes': 'Percent of Complaints Disputed',\n", + " dispute_category: 'State',\n", + " },\n", + ")\n", + "fig.show('notebook_connected')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Consumers in the west coast seem to be more likely to dispute their complaint resolutions compared to the rest of the country, followed by the east coast. The middle region of the country, highlighted by New Mexico and South Dakota, have much lower dispute rates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create bar graph to visualize proportions of each submition method that was disputed" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dispute_category = 'submitted_via'\n", + "\n", + "sub_df = get_frequency_df(dispute_category)\n", + "\n", + "fig = px.bar(\n", + " sub_df,\n", + " x=dispute_category,\n", + " y='percent_disputes',\n", + " title='Submition Method vs Percentage of Consumer Disputes',\n", + " labels={\n", + " 'consumer_disputed?': 'Consumer Disputes',\n", + " 'percent_disputes': 'Percent of Complaints Disputed',\n", + " dispute_category: 'Submitted Via', \n", + " },\n", + " range_y=[13, 23]\n", + ")\n", + "fig.show('notebook_connected')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Web submissions, which also happen to be the most common form of complaint submission, have the highest dispute rate. On the other hand, postal mail submissions, which are one of the least common methods for complaint submissions, have the lowest dispute rates.\n", + "\n", + "A trend that I notice is that instant and non-verbal forms of communication (web, fax, email) have higher dispute rates than slower, non-anonymous methods of submission (referral, phone, postal mail). Could the attributes of the latter category create a barrier that discourages consumers from disputing the resolutions of their claims?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use NLP and sentiment analysis to create a word cloud that visualizes the most common issues within complaints" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 399.5, 199.5, -0.5)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.issue = df.issue.apply(str.lower)\n", + "words = ''\n", + "for issue in df.issue:\n", + " words += issue + ' '\n", + "\n", + "wordcloud = cloud.WordCloud(\n", + " stopwords=set(cloud.STOPWORDS),\n", + " min_font_size=5,\n", + " background_color='white',\n", + ").generate(words)\n", + "plt.imshow(wordcloud)\n", + "plt.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use NLP and sentiment analysis to create a word cloud that visualizes the most common issues within *disputed* complaints" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 399.5, 199.5, -0.5)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "word_df = df\n", + "word_df = word_df[word_df['consumer_disputed?'] == 1] # Filter the df to only include disputed claims\n", + "words = ''\n", + "for issue in word_df.issue:\n", + " words += issue + ' '\n", + "\n", + "wordcloud = cloud.WordCloud(\n", + " stopwords=set(cloud.STOPWORDS),\n", + " min_font_size=5,\n", + " background_color='white',\n", + ").generate(words)\n", + "plt.imshow(wordcloud)\n", + "plt.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A form of modification (loan, collection) is the most common issue found in sentiment analysis. Credit reports seem to be less common among disputes than all issues. However, servicing payments seems to be an issue that leads to greater disputes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### One-Hot Encoding for ML Implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Every non-`int` feature has a relatively low number of unique values (< 100). This makes the data a good candidate for one-hot encoding, which creates a new binary column for every unique value of non-`int` columns." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date_received 1608\n", + "product 11\n", + "issue 95\n", + "state 62\n", + "submitted_via 6\n", + "date_sent_to_company 1557\n", + "company_response_to_consumer 2\n", + "timely_response 2\n", + "consumer_disputed? 2\n", + "dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.nunique()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Int64Index: 551070 entries, 0 to 553096\n", + "Data columns (total 9 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 date_received 551070 non-null int64 \n", + " 1 product 551070 non-null object\n", + " 2 issue 551070 non-null object\n", + " 3 state 551070 non-null object\n", + " 4 submitted_via 551070 non-null object\n", + " 5 date_sent_to_company 551070 non-null int64 \n", + " 6 company_response_to_consumer 551070 non-null int64 \n", + " 7 timely_response 551070 non-null int64 \n", + " 8 consumer_disputed? 551070 non-null int64 \n", + "dtypes: int64(5), object(4)\n", + "memory usage: 42.0+ MB\n" + ] + } + ], + "source": [ + "df = df.infer_objects()\n", + "df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create one-hot encoded columns and drop the original categorical columns." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "categorical_cols = ['product', 'issue', 'state', 'submitted_via']\n", + "ohe_df = df\n", + "for col in categorical_cols:\n", + " col_ohe = pd.get_dummies(ohe_df[col], prefix=col) # Create new numerical columns off of values in categorical column\n", + " ohe_df = pd.concat((ohe_df, col_ohe), axis=1).drop(col, axis=1) # Add columns to df and drop original categorical column" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As seen below, there are only numerical features as all of the categorical columns were encoded into binary features." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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", + "
date_receiveddate_sent_to_companycompany_response_to_consumertimely_responseconsumer_disputed?product_Bank account or serviceproduct_Consumer Loanproduct_Credit cardproduct_Credit reportingproduct_Debt collection...state_WAstate_WIstate_WVstate_WYsubmitted_via_Emailsubmitted_via_Faxsubmitted_via_Phonesubmitted_via_Postal mailsubmitted_via_Referralsubmitted_via_Web
073511073511411100000...0000000010
173511073511411100000...0000000010
273511073512911000010...0000000100
373511073511011100000...0000100000
473511073511011100001...0000000001
\n", + "

5 rows × 179 columns

\n", + "
" + ], + "text/plain": [ + " date_received date_sent_to_company company_response_to_consumer \\\n", + "0 735110 735114 1 \n", + "1 735110 735114 1 \n", + "2 735110 735129 1 \n", + "3 735110 735110 1 \n", + "4 735110 735110 1 \n", + "\n", + " timely_response consumer_disputed? product_Bank account or service \\\n", + "0 1 1 0 \n", + "1 1 1 0 \n", + "2 1 0 0 \n", + "3 1 1 0 \n", + "4 1 1 0 \n", + "\n", + " product_Consumer Loan product_Credit card product_Credit reporting \\\n", + "0 0 0 0 \n", + "1 0 0 0 \n", + "2 0 0 1 \n", + "3 0 0 0 \n", + "4 0 0 0 \n", + "\n", + " product_Debt collection ... state_WA state_WI state_WV state_WY \\\n", + "0 0 ... 0 0 0 0 \n", + "1 0 ... 0 0 0 0 \n", + "2 0 ... 0 0 0 0 \n", + "3 0 ... 0 0 0 0 \n", + "4 1 ... 0 0 0 0 \n", + "\n", + " submitted_via_Email submitted_via_Fax submitted_via_Phone \\\n", + "0 0 0 0 \n", + "1 0 0 0 \n", + "2 0 0 0 \n", + "3 1 0 0 \n", + "4 0 0 0 \n", + "\n", + " submitted_via_Postal mail submitted_via_Referral submitted_via_Web \n", + "0 0 1 0 \n", + "1 0 1 0 \n", + "2 1 0 0 \n", + "3 0 0 0 \n", + "4 0 0 1 \n", + "\n", + "[5 rows x 179 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ohe_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Logistic Regression Classification Model Creation and Evaluation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the data consists only of numerical features, it can be interpreted by a numerical classification model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Split the data into 80% training and 20% testing sets" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "target = 'consumer_disputed?'\n", + "X = ohe_df.drop(target, axis=1)\n", + "y = ohe_df[target]\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, stratify=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a Logistic Regression classifier, fit the model on the training data, and create a prediction vector on the testing features." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "clf = LogisticRegression()\n", + "clf.fit(X_train, y_train)\n", + "y_pred = clf.predict(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Evaluate the raw accuracy of the model by comparing the predicted labels and the actual labels of the testing set" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 79.81%\n" + ] + } + ], + "source": [ + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(f\"Accuracy: {round(accuracy * 100, 2)}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Without any hyperparameter tuning and customization, an 80% accuracy appears to be reasonably strong! But..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a confusion matrix to examine precision and recall of the model" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "matrix = plot_confusion_matrix(clf, X_test, y_test, cmap=plt.cm.Blues)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It appears that **every** true consumer dispute is predicted incorrectly as a non-dispute. In the real world, this would mean that the model would predict that the consumer would not dispute the claim resolution every time, making it relatively useless to our financial institution." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.80 1.00 0.89 87958\n", + " 1 0.00 0.00 0.00 22256\n", + "\n", + " accuracy 0.80 110214\n", + " macro avg 0.40 0.50 0.44 110214\n", + "weighted avg 0.64 0.80 0.71 110214\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like we have a recall of **0** (!) for true disputes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try to lower the threshold of our model to increase its recall. See this website for the math behind how this optimal threshold value was calculated." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best Threshold: 0.20192467793497948\n", + "G-Mean: 0.5044667432872447\n" + ] + } + ], + "source": [ + "from sklearn.metrics import roc_curve, confusion_matrix\n", + "yhat = clf.predict_proba(X_test)\n", + "y_hat = [i[1] for i in yhat]\n", + "fpr, tpr, thresholds = roc_curve(y_test.values, y_hat)\n", + "gmeans = np.sqrt(tpr * (1 - fpr))\n", + "ix = np.argmax(gmeans)\n", + "print(f\"Best Threshold: {thresholds[ix]}\\nG-Mean: {gmeans[ix]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 51.43%\n" + ] + } + ], + "source": [ + "threshold = thresholds[ix]\n", + "decisions = (clf.predict_proba(X_test)[:,1] >= threshold).astype(int)\n", + "accuracy = accuracy_score(y_test.values, decisions)\n", + "print(f\"Accuracy: {round(accuracy * 100, 2)}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the overall accuracy of the model took a huge hit. But, let's see if it can predict true disputes more accurately." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[45814 42144]\n", + " [11382 10874]]\n", + " precision recall f1-score support\n", + "\n", + " 0 0.80 0.52 0.63 87958\n", + " 1 0.21 0.49 0.29 22256\n", + "\n", + " accuracy 0.51 110214\n", + " macro avg 0.50 0.50 0.46 110214\n", + "weighted avg 0.68 0.51 0.56 110214\n", + "\n" + ] + } + ], + "source": [ + "print(confusion_matrix(y_test.values, decisions))\n", + "print(classification_report(y_test, decisions))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, the recall for true disputes is 49%, which is much greater than our original value but still pretty low. This quick and dirty ML model still needs a lot more tuning and bias reduction before it can be deployed in the real world." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Conclusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Despite our visualizations and insights, our ML model still needs a lot of improvement before it can be implemented in the real world. Still, we can use these insights to inform the decisions we make in our financial institution when dealing with complaints in the future." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.13 64-bit", + "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.9.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "9d9b8f8f01158b4162c6eca0c9e04004bdc609bdc275ae8230f5f735bd433193" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/reflection.pdf b/reflection.pdf new file mode 100644 index 0000000..7c649b9 Binary files /dev/null and b/reflection.pdf differ diff --git a/report.pdf b/report.pdf new file mode 100644 index 0000000..31e16c3 Binary files /dev/null and b/report.pdf differ diff --git a/resources/letterhead.png b/resources/letterhead.png new file mode 100644 index 0000000..35c4fd0 Binary files /dev/null and b/resources/letterhead.png differ diff --git a/resources/letterhead2.png b/resources/letterhead2.png new file mode 100644 index 0000000..39aa369 Binary files /dev/null and b/resources/letterhead2.png differ diff --git a/resources/visualizations/all-complaints-wc.png b/resources/visualizations/all-complaints-wc.png new file mode 100644 index 0000000..a6b7826 Binary files /dev/null and b/resources/visualizations/all-complaints-wc.png differ diff --git a/resources/visualizations/disputed-complaints-wc.png b/resources/visualizations/disputed-complaints-wc.png new file mode 100644 index 0000000..3197959 Binary files /dev/null and b/resources/visualizations/disputed-complaints-wc.png differ diff --git a/resources/visualizations/product-disputes.png b/resources/visualizations/product-disputes.png new file mode 100644 index 0000000..1b7ae53 Binary files /dev/null and b/resources/visualizations/product-disputes.png differ diff --git a/resources/visualizations/state-disputes.png b/resources/visualizations/state-disputes.png new file mode 100644 index 0000000..158ce25 Binary files /dev/null and b/resources/visualizations/state-disputes.png differ diff --git a/resources/visualizations/submission-disputes.png b/resources/visualizations/submission-disputes.png new file mode 100644 index 0000000..6dd46f1 Binary files /dev/null and b/resources/visualizations/submission-disputes.png differ