Loan Default Prediction with Random Forest and SHAP Explanations

Loan default prediction with Random Forest and SHAP explanations tackles a lending problem: a lender must judge, before money is disbursed, whether a borrower will repay or stop paying. Traditional scorecards use a handful of hand-set rules, so they miss interactions — for example, a moderate income looks safe until it is combined with a high interest rate and a high debt-to-income ratio. A Random Forest learns those interactions from thousands of past loans instead, because each tree splits on different features and the forest votes on the outcome. The catch is opacity: a vote share alone does not tell a reviewer why one applicant was flagged and another was not. SHAP explanations close that gap by sharing the prediction fairly among the applicant's features, so every decision can be inspected, challenged and documented. That combination makes the system useful as a teaching build and a demonstration of responsible credit modelling.

Lenders, banks and peer-to-peer platforms all face the same asymmetry: approving a loan that defaults loses principal, while rejecting a loan that would have repaid loses interest income. A model that only outputs a score hides which side of that trade-off drove the decision, and a reviewer cannot defend or overturn it. This build therefore treats explanation as a first-class output, not an add-on chart: every prediction ships with its ranked feature contributions, a probability, and a Low, Review or High band. The result is a system a student can walk through end to end — from raw loan records to a justified decision — and a reviewer can interrogate feature by feature.

This is a built-to-order software project: the training notebook, trained model, explanation outputs, web demo and the complete documentation set are prepared fresh for you.

Concept
The concept has two halves that must be understood together. A Random Forest is an ensemble of decision trees: each tree is trained on a different bootstrap sample of loans and a random subset of features, and the forest's prediction is the share of trees voting for default. SHAP (SHapley Additive exPlanations) then explains that vote share by distributing it fairly among the features, using the game-theoretic Shapley value: each feature's contribution is its average marginal effect across all possible feature orderings. Because the contributions are additive, they sum exactly to the gap between the average prediction and the applicant's own prediction — which is why a SHAP bar chart can be read as a complete account of one decision, not a rough ranking.

Loan default prediction with Random Forest and SHAP explanations works end to end in four stages. First, applicant and loan features — amount, income, interest rate, debt-to-income ratio, credit score, employment length, revolving utilisation, open accounts, grade, home ownership and purpose — are cleaned, encoded and scaled into the eleven inputs the model expects. Second, a Random Forest is trained on historical LendingClub loans, where hundreds of decision trees each learn from a different sample of loans and features, then vote on whether a new loan will be repaid or charged off. Third, the share of trees voting for default becomes the predicted probability, mapped to a Low, Review or High band for presentation. Fourth, SHAP values decompose that probability feature by feature, producing a ranked list of contributions that sum exactly to the gap between the average prediction and the applicant's own score.

1. Closed LendingClub loans are loaded and filtered to the two completed outcomes, Fully Paid and Charged Off, discarding loans still in progress whose outcome is unknown.
2. The eleven modelling features are selected, missing values are handled, categorical fields (grade, home ownership, purpose) are encoded, and leakage fields such as post-outcome payment totals are excluded.
3. The data is split with stratification so the train and test sets carry the same default rate, and class weights are set to balanced so minority defaults are not ignored.
4. A Random Forest of 300 trees (design target) is trained with cross-validation used to check the depth, leaf-size and feature-subset settings before the final fit.
5. The held-out test set is evaluated once with a confusion matrix, ROC-AUC, PR-AUC and per-class precision, recall and F1, and the decision threshold and risk bands are fixed from those results.
6. SHAP TreeExplainer values are computed for test predictions and for any new applicant, producing the ranked contribution chart shown in the demo.
7. In the web demo, an applicant profile is scored through the same eleven-feature pipeline and displayed with its probability, risk band and SHAP contributions.

Tech stack:

• Python 3, scikit-learn (Random Forest)
• SHAP TreeExplainer
• pandas, NumPy (data preparation)
• LendingClub loan data via Kaggle
• Jupyter Notebook (training & evaluation)
• HTML, CSS, JavaScript (scoring & explanation demo)
• Matplotlib, Seaborn (evaluation plots)

Dataset & model details

• Dataset: LendingClub Loan Data, via Kaggle — a large public file of historical peer-to-peer loans; published Kaggle versions range from roughly 890,000 to 2.2 million rows with 150 or more columns depending on the version, so the build documents the exact version used at training time. The build uses the closed-loan subset only, i.e. loans whose outcome is known. Classes: 2 — Fully Paid (loan repaid, label 0) and Charged Off (loan defaulted and written off, label 1).
• Task: Binary classification; input = 11 applicant and loan features (amount, income, interest rate, debt-to-income ratio, credit score, employment length, revolving utilisation, open accounts, grade, home ownership, purpose); output = default probability from 0% to 100% plus a Low / Review / High band.
• Model: Random Forest classifier, 300 trees (design target), trained on the closed-loan subset with balanced class weights; the demo's scoring rule is a transparent approximation of the trained forest, labelled as such inside the demo, while the delivered notebook trains and explains the real forest with SHAP TreeExplainer.
• Metrics: ROC-AUC, PR-AUC, confusion matrix, per-class precision, recall and F1. No accuracy is claimed as measured: the built-to-order training run reports the achieved figures, against a design target of ROC-AUC above 0.75.

Loan default prediction with Random Forest and SHAP explanations ships as a complete, inspectable credit-risk build: a trained Random Forest, a SHAP explanation for every prediction, and a web demo that scores any applicant profile on demand. The classifier takes eleven applicant and loan features — amount, income, interest rate, debt-to-income ratio, credit score, employment length, revolving utilisation, open accounts, grade, home ownership and purpose — and returns a default probability with a Low, Review or High band. The explanation panel then ranks each feature by its contribution, so a reviewer sees exactly what pushed the score up or down instead of trusting a bare number. A portfolio view scores six illustrative applicants side by side, showing how risk moves when income, rate and credit score change together. Together, these capabilities let a student demonstrate training, evaluation, explanation and presentation in one coherent build.

• [Random Forest classifier] An ensemble of decision trees trained on historical loan records, returning a default probability rather than a bare yes/no label, so borderline applicants stay visible instead of being forced into a hard class.
• [SHAP explanation for every prediction] Each prediction is decomposed into per-feature contributions that sum to the gap between the average prediction and the applicant's score, rendered as a ranked bar chart with a plain-language reading guide.
• [Interactive applicant scoring demo] A single-file web demo with eleven applicant inputs, three preset profiles (low-risk, borderline, high-risk) and instant scoring, so any profile can be tested and explained without running code.
• [Class-imbalance handling] Defaults are the minority class, so the build uses a stratified train/test split, balanced class weights and class-aware evaluation instead of headline accuracy alone, which would flatter a model that simply predicts "repaid" for everyone.
• [Threshold and risk banding] The default probability is mapped to Low (below 30%), Review (30–60%) and High (above 60%) bands, with the decision threshold documented and adjustable, so the trade-off between missed defaults and false alarms is explicit.
• [Portfolio comparison view] Six illustrative applicants are scored side by side in the demo, showing how the band moves when income, interest rate and credit score change together.
• [Evaluation report] Confusion matrix, ROC-AUC, PR-AUC and per-class precision, recall and F1, plus forest feature importance and a SHAP summary plot, all documented for the review discussion.

Optional customisation (not in the base build): a custom institutional dataset swap, a calibration curve and probability calibration, a fairness slice report across applicant groups, and a Flask API deployment of the trained model. Future scope (not implemented): online learning on new loans, bureau-data integration, and a mobile applicant-entry app.

Builder note, measured from the demo build: the preset borderline applicant (loan 18,000, income 72,000, interest rate 13.5%, debt-to-income 22%, credit score 690) scored 39.2% default probability in the working demo, in the Review band, with debt-to-income as its largest single push toward default at +0.22 log-odds; the demo's own arithmetic reads base value -1.20 plus contributions +0.76 equals a final score of -0.44 log-odds.

• Complete training & evaluation Jupyter notebook (data loading, filtering, preprocessing, training, evaluation, SHAP analysis)
• Trained Random Forest model file with the preprocessing pipeline
• Interactive web demo: applicant scoring, SHAP explanation view and portfolio comparison view
• Evaluation report: confusion matrix, ROC-AUC, PR-AUC, per-class metrics, feature importance and SHAP summary plot
• Project report PDF (background, Random Forest theory, SHAP method, methodology, results, limitations)
• PPT presentation for final review
• Review Q&A preparation document (ensembles, bagging, Shapley values, class imbalance, threshold trade-offs)

Requirements

• Python 3 with scikit-learn, SHAP, pandas, NumPy, Matplotlib and Seaborn (listed in a requirements file)
• Jupyter Notebook for the training run; any modern browser for the demo (no server needed)
• Approximately 2 GB of free disk space for the dataset and model artefacts (expected)
• A laptop with approximately 8 GB of RAM for the full training run (expected); the demo runs on any machine that opens the HTML file