Case Study: Loan Payback Prediction¶
Introduction¶
LendingClub is a US peer-to-peer lending company, headquartered in San Francisco, California. It was the first peer-to-peer lender to register its offerings as securities with the Securities and Exchange Commission (SEC), and to offer loan trading on a secondary market. LendingClub is the world's largest peer-to-peer lending platform.
Problem:
- Given historical data on loans given out with information on whether or not the borrower defaulted (charge-off), build a model that can predict whether or nor a borrower will pay back their loan. This way in the future when a new potential customer, they can assess whether or not they are likely to pay back the loan.
Dataset:
- Historical data of LendingClub
Source: https://www.lendingclub.com/
Review¶
An artificial neural network is an interconnected group of nodes, inspired by a simplification of neurons in a brain. Here, each circular node represents an artificial neuron and an arrow represents a connection from the output of one artificial neuron to the input of another.
ANNs are composed of artificial neurons which are conceptually derived from biological neurons. Each artificial neuron has inputs and produce a single output which can be sent to multiple other neurons. The inputs can be the feature values of a sample of external data, such as images or documents, or they can be the outputs of other neurons. The outputs of the final output neurons of the neural net accomplish the task, such as recognizing an object in an image.
Libraries And Data Importation¶
In [3]:
# Import libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
In [4]:
# Import data
df = pd.read_csv('lending_club_loan.csv')
Data Exploration¶
In [3]:
# Check dataframe
df.head()
Out[3]:
In [4]:
# Check data statistics
df.describe()
Out[4]:
In [5]:
# Check more info
df.info()
Data Visualizaton¶
In [6]:
# Visualize data
sns.countplot(x = 'loan_status' , data = df)
plt.show()
In [7]:
# visualize data
plt.figure(figsize = (12,4))
sns.distplot(df['loan_amnt'], kde = False, bins = 40)
plt.show()
In [8]:
# Check data correlation
df.corr()
Out[8]:
In [9]:
# Visualize data correlation
plt.figure(figsize = (12, 7))
sns.heatmap(df.corr(), annot = True, cmap = 'viridis')
plt.show()
In [10]:
# Visualize data
sns.scatterplot(x = 'installment', y = 'loan_amnt', data = df)
plt.show()
In [11]:
# Visualize data
sns.boxplot(x = 'loan_status', y = 'loan_amnt', data = df)
plt.show()
In [12]:
# Check summary statistics
df.groupby('loan_status')['loan_amnt'].describe()
Out[12]:
In [13]:
# Check for unique values
df['grade'].unique()
Out[13]:
In [14]:
# Check for unique values
df['sub_grade'].unique()
Out[14]:
In [15]:
# Visualize data
sns.countplot(x = 'grade', data = df, hue = 'loan_status')
plt.show()
In [16]:
# Visualize data
plt.figure(figsize = (12, 4))
subgrade_order = sorted(df['sub_grade'].unique())
sns.countplot(x = 'sub_grade', data = df, order = subgrade_order, palette = 'coolwarm')
plt.show()
In [17]:
# Visualize data
plt.figure(figsize = (12, 4))
subgrade_order = sorted(df['sub_grade'].unique())
sns.countplot(x = 'sub_grade', data = df, order = subgrade_order, palette = 'coolwarm', hue = 'loan_status')
plt.show()
In [18]:
# Visualize data
f_and_g = df[(df['grade'] == 'G') | (df['grade'] == 'F')]
plt.figure(figsize = (12, 4))
subgrade_order = sorted(f_and_g['sub_grade'].unique())
sns.countplot(x = 'sub_grade', data = f_and_g, order = subgrade_order, palette = 'coolwarm', hue = 'loan_status')
plt.show()
In [19]:
# Create new column
df['loan_repaid'] = df['loan_status'].map({'Fully Paid': 1, 'Charged Off': 0})
In [20]:
# Check dataframe
df[['loan_repaid', 'loan_status']]
Out[20]:
In [21]:
# Visualize correlation impact
plt.figure(figsize = (8, 4))
df.corr()['loan_repaid'].sort_values().drop('loan_repaid').plot(kind = 'bar')
plt.show()
Data Preprocessing¶
Feature Engineering¶
In [22]:
# Check dataframe length
len(df)
Out[22]:
In [23]:
# Check for missing values
df.isnull().mean()
Out[23]:
In [24]:
# Check the percentage of missing data
(df.isnull().sum() / len(df)) * 100
Out[24]:
In [25]:
# Check data unique counts
df['emp_title'].nunique()
Out[25]:
In [26]:
# check for value counts
df['emp_title'].value_counts()
Out[26]:
In [27]:
# Drop column
df = df.drop('emp_title', axis = 1)
In [28]:
# check and dort data column
sorted(df['emp_length'].dropna().unique())
Out[28]:
In [29]:
# Rearrange column data
emp_length_order = [
'< 1 year'
'1 year',
'2 years',
'3 years',
'4 years',
'5 years',
'6 years',
'7 years',
'8 years',
'9 years',
'10+ years']
In [30]:
# Visualize data
plt.figure(figsize = (12, 3))
sns.countplot(x = 'emp_length', data = df, order = emp_length_order, hue = 'loan_status')
plt.show()
In [31]:
# Create filtered dataframe
emp_co = df[df['loan_status'] == 'Charged Off'].groupby('emp_length').count()['loan_status']
# Check dataframe
emp_co
Out[31]:
In [32]:
# Create filtered dataframe
emp_fp = df[df['loan_status'] == 'Fully Paid'].groupby('emp_length').count()['loan_status']
# Check dataframe
emp_fp
Out[32]:
In [33]:
# Check ratio
emp_co / emp_fp
Out[33]:
In [34]:
# Create label
emp_len = emp_co / (emp_co + emp_fp)
In [35]:
# Visualize data
emp_len.plot(kind = 'bar')
plt.show()
In [36]:
# Drop column
df = df.drop('emp_length', axis = 1)
In [37]:
# Check data column
df['purpose'].head(10)
Out[37]:
In [38]:
# Check data column
df['title'].head(10)
Out[38]:
In [39]:
# Drop column
df = df.drop('title', axis = 1)
In [40]:
# Check data column value counts
df['mort_acc'].value_counts()
Out[40]:
In [41]:
# Check specified correlation
df.corr()['mort_acc'].sort_values()
Out[41]:
In [42]:
# compare each column by mean according to a specific column
df.groupby('total_acc').mean()
Out[42]:
In [43]:
# create new data frame
total_acc_avg = df.groupby('total_acc').mean()['mort_acc']
# Check dataframe
total_acc_avg
Out[43]:
In [44]:
# Create function
def fill_mort_acc(total_acc, mort_acc):
if np.isnan(mort_acc):
return total_acc_avg[total_acc]
else:
return mort_acc
In [45]:
df['mort_acc'] = df.apply(lambda x: fill_mort_acc(x['total_acc'], x['mort_acc']), axis = 1) # Lambda = apply function to two pandas dataframe
In [46]:
# Check for missing values
df.isnull().mean()
Out[46]:
In [47]:
# Drop columns
df = df.dropna()
In [48]:
# Check for missing values
df.isnull().mean()
Out[48]:
Categorical Encoding¶
In [49]:
# Check string columns
df.select_dtypes(['object']).columns
Out[49]:
In [50]:
# Check value counts
df['term'].value_counts()
Out[50]:
In [51]:
# Take only the first two characters
df['term'] = df['term'].apply(lambda term: int(term[:3]))
In [52]:
# Check data column
df['term'].value_counts()
Out[52]:
In [53]:
# Drop column
df = df.drop('grade', axis = 1)
In [54]:
# Get dummies
dummies = pd.get_dummies(df['sub_grade'], drop_first = True)
# Removie the original column and concat the dummies
df = pd.concat([df.drop('sub_grade', axis = 1), dummies], axis = 1)
In [55]:
# check data column
df.columns
Out[55]:
In [56]:
# Get dummies
dummies = pd.get_dummies(df[['verification_status', 'application_type', 'initial_list_status','purpose']], drop_first = True)
# Removie the original column and concat the dummies
df = pd.concat([df.drop(['verification_status', 'application_type','initial_list_status','purpose'], axis = 1), dummies], axis = 1)
In [57]:
# Check value counts
df['home_ownership'].value_counts()
Out[57]:
In [58]:
# Replace values
df['home_ownership'] = df['home_ownership'].replace(['NONE', 'ANY'], 'OTHER')
In [59]:
# Check value counts
df['home_ownership'].value_counts()
Out[59]:
In [60]:
# Get dummies
dummies = pd.get_dummies(df['home_ownership'], drop_first = True)
# Removie the original column and concat the dummies
df = pd.concat([df.drop('home_ownership', axis = 1), dummies], axis = 1)
In [61]:
# Check dataframe
df.head()
Out[61]:
In [62]:
# Check column
df['address']
Out[62]:
In [63]:
# Take last five characters
df['zip_code'] = df['address'].apply(lambda address:address[-5:])
# Check data column
df['zip_code']
Out[63]:
In [64]:
# Check value counts
df['zip_code'].value_counts()
Out[64]:
In [65]:
# Get dummies
dummies = pd.get_dummies(df['zip_code'], drop_first = True)
# Removie the original column and concat the dummies
df = pd.concat([df.drop('zip_code', axis = 1), dummies], axis = 1)
# Drop the original column
df = df.drop('address', axis = 1)
In [66]:
# Drop column
df = df.drop('issue_d', axis = 1)
In [67]:
# Check data column
df['earliest_cr_line']
Out[67]:
In [68]:
# Get the last 4 characters
df['earliest_cr_line'] = df['earliest_cr_line'].apply(lambda date: int(date[-4:]))
In [69]:
# Check data column
df['earliest_cr_line']
Out[69]:
Data Splitting And Scaling¶
In [72]:
# Drop data column
df = df.drop('loan_status', axis = 1)
In [73]:
# Set the x and y variables
X = df.drop('loan_repaid', axis = 1).values
y = df['loan_repaid'].values
In [74]:
# Import library
from sklearn.model_selection import train_test_split
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)
In [75]:
# Import library
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Normalize the data
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Model Creation¶
In [76]:
# Import libraries
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation,Dropout
from tensorflow.keras.constraints import max_norm
In [77]:
# Create model architecture
model = Sequential()
# Input layer
model.add(Dense(78, activation='relu'))
model.add(Dropout(0.2))
# Hidden layer
model.add(Dense(39, activation='relu'))
model.add(Dropout(0.2))
# Hidden layer
model.add(Dense(19, activation='relu'))
model.add(Dropout(0.2))
# Output layer
model.add(Dense(units=1,activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam')
In [78]:
# Train the model
model.fit(x=X_train,
y=y_train,
epochs=25,
batch_size=256,
validation_data=(X_test, y_test),
)
Out[78]:
Model Evaluation¶
In [79]:
# Check dataframe
pd.DataFrame(model.history.history)
Out[79]:
In [82]:
# label the dataframe
losses = pd.DataFrame(model.history.history)
# Plot the evaluation metrics
losses[['loss','val_loss']].plot()
plt.show()
In [85]:
# Import library
from sklearn.metrics import classification_report,confusion_matrix
# Set prediction
predictions = model.predict_classes(X_test)
print(classification_report(y_test,predictions))
In [86]:
# Check confusion matrix
confusion_matrix(y_test,predictions)
Out[86]:
Sample Prediction¶
In [87]:
# Create sample
import random
random.seed(101)
random_ind = random.randint(0,len(df))
new_customer = df.drop('loan_repaid', axis=1).iloc[random_ind]
new_customer
Out[87]:
In [88]:
# Predict Sample
model.predict_classes(new_customer.values.reshape(1,78))
Out[88]:
In [89]:
# True value
df.iloc[random_ind]['loan_repaid']
Out[89]:
Save Model¶
In [90]:
# Import library
from tensorflow.keras.models import load_model
# Save the model
model.save('full_data_project_model.h5')
Conclusion¶
The model was able to obtained 89% accuracy but there was an issue, the dataset was imbalance. There were more 'Fully paid' than 'Charged off' which has a probability of 80% by just guessing Fully Paid. Possible solution for that is Re-sampling the training dataset (Under-sampling or over-sampling and then apply k-fold cross validation.