Credit Default Classifier Model

            # courtesy of critical spaghetti

"""PD Model with Random Forest Algorithm

Original file is located at
    https://colab.research.google.com/drive/12nOdAKmd-UaBwfrar4146fox94PQ6rp3

# Loading the dependencies
"""

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, GridSearchCV, learning_curve
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
import pandas as pd
import matplotlib.pyplot as plt

"""# Loading the CSV into the dataframe"""

# Load the dataset from the provided link
csv_link = "https://sushilparajuli.com/wp-content/uploads/2024/02/bankloans.csv"
df = pd.read_csv(csv_link)

# Drop rows with missing values
df = df.dropna()

# Extract features and target variable
x = df.drop(['default'], axis=1)
y = df['default']

"""# Splitting into training / testing set and Scaling for non-uniformity"""

# Split the data into training and testing sets
xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=0.2, random_state=42)

# Standardize the feature data using StandardScaler
sc = StandardScaler()
xtrain = sc.fit_transform(xtrain)
xtest = sc.fit_transform(xtest)

"""# Training the Default Classifier Model using Random Forest Algorithm"""

# Hyperparameter tuning for Random Forest Classifier with an extended search space
param_grid = {
    'n_estimators': [200, 300],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5],
    'min_samples_leaf': [1, 2],
    'max_features': ['auto', 'sqrt', 'log2'],
    'bootstrap': [True, False]
}

# Create a Random Forest Classifier
rfc = RandomForestClassifier()

# Use GridSearchCV to find the best hyperparameters
grid_search = GridSearchCV(estimator=rfc, param_grid=param_grid, scoring='accuracy', cv=5, n_jobs=-1)
grid_search.fit(xtrain, ytrain)

"""# Plotting the grid search progress"""

# Extract the results of the grid search
results = pd.DataFrame(grid_search.cv_results_)

# Extract relevant information for plotting
param_cols = ['param_' + param for param in param_grid.keys()]
mean_test_scores = results['mean_test_score']

# Handle 'max_features' separately as it is a categorical variable
max_features_values = results['param_max_features']
unique_max_features = max_features_values.unique()

# Create line plots for each hyperparameter
plt.figure(figsize=(16, 10))
for max_feature_value in unique_max_features:
    mask = (max_features_values == max_feature_value)
    plt.plot(results[mask]['param_max_depth'], mean_test_scores[mask], marker='o', label=f'max_features={max_feature_value}')

# Set labels and title
plt.xlabel('max_depth')
plt.ylabel('Mean Test Score')
plt.title('Grid Search Progress')
plt.legend()
plt.grid(True)
plt.show()

"""Retraining the default rate classifier with the best parameters"""

# Create a Random Forest Classifier with the best hyperparameters from the grid search
best_params = grid_search.best_params_
rfc_best = RandomForestClassifier(**best_params)

# Get the best parameters and retrain the model
best_params = grid_search.best_params_
best_rfc = RandomForestClassifier(**best_params)
best_rfc.fit(xtrain, ytrain)

"""# Plotting the learning curve of the classifier model"""

# Plot learning curve
plt.figure(figsize=(12, 8))
train_sizes, train_scores, test_scores = learning_curve(rfc_best, xtrain, ytrain, cv=5, scoring='accuracy', train_sizes=np.linspace(0.1, 1.0, 10))

# Calculate mean and standard deviation of training and test scores
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

# Plot the learning curve
plt.plot(train_sizes, train_mean, label='Training Score', marker='o')
plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.15)
plt.plot(train_sizes, test_mean, label='Validation Score', marker='o')
plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, alpha=0.15)

# Set labels and title
plt.xlabel('Training Examples')
plt.ylabel('Accuracy Score')
plt.title('Learning Curve')
plt.legend()
plt.grid(True)
plt.show()

"""# How accurate is the default classifier model?"""

# Evaluate the improved Random Forest model on the test set
improved_score = best_rfc.score(xtest, ytest)
print("Improved Random Forest Classifier Accuracy:", improved_score)

# Display classification report for more detailed evaluation
ypred = best_rfc.predict(xtest)
print("\nClassification Report:\n", classification_report(ytest, ypred))

"""# Try this classifying model with your own data"""

# Create a DataFrame for new data
new_data = pd.DataFrame({
    'age': [41], # Age of the Customers
    'ed': [1], # Education Level
    'employ': [17], # Work Experience in Years
    'address': [12], # Address of the Customer
    'income': [176], # Yearly Income of the customer
    'debtinc': [9.3], # Debt to Income Ratio
    'creddebt': [11.359392], # Credit to Debt ratio
    'othdebt': [5.008608] # Other debts
})

# Will predict you the default rate Customer defaulted in the past (1= defaulted, 0=Never defaulted)

# Preprocess the new data using the same StandardScaler object
new_data_scaled = sc.transform(new_data)

# Use the trained RFC model to make predictions on the new data
prediction = best_rfc.predict(new_data_scaled)

# Print or use the prediction as needed
print("ill predict you the default rate Customer defaulted in the past (1= defaulted, 0=Never defaulted)")
print("Predicted Default for the dataframe you entered above :", prediction[0])