Predicting Loan Approval

# Import required libraries and read in dataset
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

loan_df = pd.read_csv("loan_train_data.csv")
loan_df.head()

loan_df.info()

# Remove redundant id column
loan_df.drop("id", axis=1, inplace=True)

loan_df["person_home_ownership"].value_counts()

loan_df["loan_intent"].value_counts()

loan_df["loan_grade"].value_counts()

loan_df["cb_person_default_on_file"].value_counts()

# Draw a histogram for all the numeric features
loan_df.hist(figsize=(12,8))
plt.show()

loan_df["person_age"].max()

loan_df[loan_df["person_age"]==123]

loan_df["person_age"].value_counts()

# Remove the person aged 123
loan_df.drop(loan_df[loan_df["person_age"]==123].index, inplace=True)
loan_df["person_age"].max()

loan_df["person_income"].describe().round()

loan_df["person_emp_length"].describe().round()

loan_df[loan_df["person_emp_length"]==123]

# Remove the people with 123 years of employment
loan_df.drop(loan_df[loan_df["person_emp_length"]==123].index, inplace=True)
loan_df["person_emp_length"].max()

loan_df.reset_index(inplace=True)

# Split the features into numeric and categoric data
loan_df_num = loan_df.drop(columns=["person_home_ownership", "loan_intent", "loan_grade", 
                                    "cb_person_default_on_file", "loan_status"], axis=1)
loan_df_cat = loan_df[["person_home_ownership", "loan_intent", "loan_grade", 
                                    "cb_person_default_on_file"]]
# Create the labels
loan_df_lab = loan_df["loan_status"]

# Use StandardScalar to scale the features
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaled_loan_df_num = scaler.fit_transform(loan_df_num)
scaled_loan_df_num = pd.DataFrame(scaled_loan_df_num, columns=loan_df_num.columns)
scaled_loan_df_num.head()

# Use the Pandas built-in One Hot Encoder
onehot_loan_df_cat = pd.get_dummies(loan_df_cat, dtype=int)
onehot_loan_df_cat.head()

# Combine the numeric and categoric features 
new_loan_df = pd.concat([scaled_loan_df_num, onehot_loan_df_cat], axis=1)
new_loan_df.head()

# Make a K-Nearest Neighbors model
from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(new_loan_df, loan_df_lab)

knn.score(new_loan_df, loan_df_lab)

loan_df_lab.value_counts()

from sklearn.model_selection import cross_val_score
scores = cross_val_score(knn, new_loan_df, loan_df_lab, cv=5)
scores

from sklearn.model_selection import GridSearchCV, StratifiedKFold

param_grid = {
    "n_neighbors": [1,3,5,10,20],
    "weights": ["uniform", "distance"],
    "metric": ["minkowski", "manhattan"]
}

grid_search = GridSearchCV(estimator=knn, param_grid=param_grid, cv=StratifiedKFold(10))
grid_search.fit(new_loan_df, loan_df_lab)

print("Parameters:", grid_search.best_params_)
print("Score:", grid_search.best_score_)

from sklearn.ensemble import RandomForestClassifier 

clf = RandomForestClassifier(n_estimators=100)
clf.fit(new_loan_df, loan_df_lab)

clf.score(new_loan_df, loan_df_lab)

scores = cross_val_score(clf, new_loan_df, loan_df_lab, cv=5)
scores

param_grid = {
    "n_estimators": [15, 50, 100, 200, 500],
    "max_depth": [5, 10, 15],
    "max_features": ["sqrt", "log2", None]
}

grid_search = GridSearchCV(estimator=clf, param_grid=param_grid, cv=StratifiedKFold(10))
grid_search.fit(new_loan_df, loan_df_lab)

print("Parameters:", grid_search.best_params_)
print("Score:", grid_search.best_score_)

param_grid = {
    "n_estimators": [100],
    "max_depth": [15, 20, 25],
    "max_features": ["log2"]
}

grid_search2 = GridSearchCV(estimator=clf, param_grid=param_grid, cv=StratifiedKFold(10))
grid_search2.fit(new_loan_df, loan_df_lab)

print("Parameters:", grid_search2.best_params_)
print("Score:", grid_search2.best_score_)

test_df = pd.read_csv("loan_test_data.csv")
test_df.head()

# Keep id for submission
ids = test_df["id"]

# Remove redundant id column
test_df.drop("id", axis=1, inplace=True)
test_df.reset_index(inplace=True)

# Split the features into numeric and categoric data
test_df_num = test_df.drop(columns=["person_home_ownership", "loan_intent", "loan_grade", 
                                    "cb_person_default_on_file"], axis=1)
test_df_cat = test_df[["person_home_ownership", "loan_intent", "loan_grade", 
                                    "cb_person_default_on_file"]]
test_df_num.head()

# Use StandardScalar to scale the features
scaled_test_df_num = scaler.transform(test_df_num)
scaled_test_df_num = pd.DataFrame(scaled_test_df_num, columns=test_df_num.columns)
scaled_test_df_num.head()

# Use the Pandas built-in One Hot Encoder
onehot_test_df_cat = pd.get_dummies(test_df_cat, dtype=int)
onehot_test_df_cat.head()

# Combine the numeric and categoric features 
new_test_df = pd.concat([scaled_test_df_num, onehot_test_df_cat], axis=1)
new_test_df.head()

pred = grid_search.predict(new_test_df)
pred

submission = pd.DataFrame(pred, index=ids, columns=["loan_status"])
submission

# Write the predictions to a csv file
submission.to_csv("submission.csv")