When I first started delving into the intricacies of financial modeling in Nepal, one challenge stood out above all others: how do we empower loan officers to make fast, accurate, and understandable credit decisions without relying solely on intuition or rigid, outdated rulebooks? It's a question that directly impacts economic growth and financial stability. This post is for data scientists, machine learning engineers, and finance professionals who are ready to move beyond basic accuracy metrics and build something truly impactful. I’ll share my journey in constructing a credit risk prediction model that isn't just highly accurate, but crucially, also deeply explainable, leveraging advanced techniques like XGBoost and SHAP to provide transparent insights into every lending decision, transforming how lending decisions are made across our financial sector.
Key Takeaways
- Employing a robust preprocessing pipeline with
ColumnTransformeris crucial for handling heterogeneous financial data consistently and preventing data leakage. - Addressing class imbalance with techniques like
SMOTEwithin a pipeline ensures models don't overlook critical minority classes, leading to more balanced predictive performance. - Hyperparameter tuning with cross-validation is essential for optimizing XGBoost performance, focusing on metrics that align with business objectives beyond just accuracy.
- SHAP (SHapley Additive exPlanations) is a powerful tool for interpreting complex models like XGBoost, providing both global feature importance and local explanations for individual predictions, fostering trust and transparency.
- Operationalizing a model requires careful consideration of data schemas, error handling, and output formats to ensure seamless integration into existing financial workflows.
The Problem: Opaque Lending in a Dynamic Market
Nepali financial institutions, from commercial banks to microfinance organizations, face the critical challenge of accurately assessing credit risk. The goal is to minimize defaults and safeguard capital while simultaneously fostering economic growth through accessible lending. Historically, this has often relied on a blend of rigid scoring rules, manual review, and the subjective judgment of loan officers. While these methods have their place, they are often slow, lack adaptability to evolving economic conditions, and struggle to process the increasing volume and complexity of modern financial data. The biggest hurdle, though, is their opacity: when a loan is denied, the 'why' can be elusive, making it difficult for both the institution and the applicant to understand the decision. My mission was to build a system that offered not just a prediction, but also a clear, defensible explanation.
Data and Sources
For this project, I used the Statlog (German Credit Data) Dataset from the UCI Machine Learning Repository. This dataset is a classic benchmark for credit risk modeling, containing 20 features describing credit applicants and a binary target variable indicating good or bad credit risk. While it's not direct Nepali financial data, its structure and challenges (heterogeneous features, class imbalance) are highly representative of what one might encounter in real-world credit applications anywhere, including Nepal. The dataset is publicly available and well-documented.
Data accessed on 2024-07-15.
Step 1 — Ingesting and Understanding Heterogeneous Financial Data
The first hurdle in any data science project is getting the data into a usable format and understanding its structure. Financial datasets are inherently messy, often containing a mix of numerical, categorical, and sometimes ordinal features. My sub-problem here was to load the raw data, assign meaningful column names (as the raw file lacks headers), and perform an initial inspection to grasp feature types and potential issues.
I started by downloading the data and loading it with pandas, carefully assigning column names based on the UCI documentation. This ensures that I'm working with interpretable features from the outset.
import pandas as pd
import numpy as np
import requests
from io import StringIO
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, precision_recall_curve, roc_curve
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline as ImbPipeline
import xgboost as xgb
import shap
import json
# Define column names based on UCI documentation
column_names = [
"checking_account_status", "duration_in_months", "credit_history", "purpose",
"credit_amount", "savings_account_status", "employment_since", "installment_rate",
"personal_status_sex", "other_debtors_guarantors", "present_residence_since",
"property_type", "age_in_years", "other_installment_plans", "housing_type",
"number_existing_credits", "job_type", "num_people_liable", "telephone",
"foreign_worker", "credit_risk"
]
def load_german_credit_data(url="https://archive.ics.uci.edu/ml/machine-learning-databases/statlog/german/german.data"):
"""
Loads the German Credit Data from a URL.
"""
try:
response = requests.get(url)
response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
data = StringIO(response.text)
df = pd.read_csv(data, sep=" ", header=None, names=column_names)
# The target variable 'credit_risk' is 1 for good credit, 2 for bad credit.
# I'll convert it to 0 for good credit (majority) and 1 for bad credit (minority).
df['credit_risk'] = df['credit_risk'].map({1: 0, 2: 1})
return df
except requests.exceptions.RequestException as e:
print(f"Error downloading data: {e}")
return None
except pd.errors.EmptyDataError:
print("Error: Downloaded data is empty.")
return None
except Exception as e:
print(f"An unexpected error occurred during data loading: {e}")
return None
# Initial data loading and inspection
df = load_german_credit_data()
if df is not None:
print("Dataset head:")
print(df.head())
print("\nDataset info:")
df.info()
print("\nDataset description:")
print(df.describe())
After loading, I immediately check .head(), .info(), and .describe(). This gives me a quick overview of the data types, missing values, and statistical summaries for numerical columns. I noted that many features are categorical (represented as strings or integers requiring encoding), and the target variable needed mapping from {1, 2} to {0, 1} for binary classification, where 1 represents the 'bad credit' (minority) class.
Step 2 — Feature Engineering and Robust Preprocessing Pipeline
Raw features are rarely ready for machine learning models. My next sub-problem was to transform these raw features into a format suitable for algorithms like XGBoost, which expects numerical input. This involves encoding categorical variables and scaling numerical features. Crucially, I needed to build a reproducible preprocessing pipeline to prevent data leakage and ensure consistency between training and inference.
I used sklearn.compose.ColumnTransformer, which allows different preprocessing steps to be applied to different columns. Categorical features are handled with OneHotEncoder, and numerical features are scaled using StandardScaler. This setup is robust because it encapsulates all transformations, making it easy to apply the exact same steps to new, unseen data.
# Separate features (X) and target (y)
X = df.drop('credit_risk', axis=1)
y = df['credit_risk']
# Identify categorical and
