Profit Criterion for selecting Machine Learning Classifier (Python)

Python Machine Learning Series

Motivations

Tinh chỉnh các tham số để tối ưu hóa một tiêu chuẩn truyền thống (ROC-AUC, Recall), lựa chọn các mô hình thì nên dựa vào các tiêu chuẩn này hay chúng chỉ đóng vai trò tham khảo mà thôi? Thử nghiệm dưới đây sẽ làm sáng tỏ một phần nhằm tìm kiếm câu trả lời thích hợp cho những câu hỏi trên.

Findings

Thử nghiệm với bộ số liệu GermanCredit.csv về cấp tín dụng của một ngân hàng đại Đức (dữ liệu có thể download tại đây) thì GaussianNB, Random Forest và CatBoostClassifier có Recall trung bình (n_splits = 4, n_repeats = 3) lần lượt là 0.567044, 0.347706, và 0.413778. Còn AUC trung bình của ba Classifiers lần lượt là 0.739503, 0.785501 và 0.792102. Python codes cho các kết quả này (ngoài 3 mô hình nêu tên ở trên còn khảo sát đồng thời 9 mô hình Machine Learning khác):

# Load data and conduct data pre-processing:
import pandas as pd

df_bank = pd.read_csv("C:/Users/ADMIN/Desktop/DataMining/dmba/GermanCredit.csv")
df_bank["RESPONSE"] = df_bank["RESPONSE"].map({1: 0, 0: 1})

# Drop OBS# feature:
my_df_binary = df_bank.drop(["OBS#"], axis=1)

# Define input features and target output:
Y = my_df_binary["RESPONSE"]
X = my_df_binary.drop("RESPONSE", axis=1)

# Prepare data:
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=29)

# Some classifiers from Scikit-learn:
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import BaggingClassifier
from sklearn.neural_network import MLPClassifier

# LightGBM, Catboost and XGBoost:
from lightgbm import LGBMClassifier
from xgboost import XGBClassifier
from catboost import CatBoostClassifier

# Initative estimators:
ran = RandomForestClassifier(random_state=9)
gbm = LGBMClassifier()
log = LogisticRegression()
gbc = GradientBoostingClassifier()
xgb = XGBClassifier()
ext = ExtraTreesClassifier()
ada = AdaBoostClassifier()
gnb = GaussianNB()
gpc = GaussianProcessClassifier()
bag = BaggingClassifier()
nnn = MLPClassifier()
cat = CatBoostClassifier()

# List of classifiers:
models = [ran, gbm, log, gbc, xgb, ext, ada, gnb, gpc, bag, nnn, cat]

# Train all classifiers:
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import cross_val_score

cv = RepeatedStratifiedKFold(n_splits=4, n_repeats=10, random_state=29)

# Cross-validation results:

import numpy as np

recall_mean = []
recall_sd = []
auc_mean = []
auc_sd = []

for mod in models:
    acc = cross_val_score(mod, X_train, y_train, scoring="recall", cv=cv, verbose=False, n_jobs=-1)
    auc = cross_val_score(mod, X_train, y_train, scoring="roc_auc", cv=cv, verbose=False, n_jobs=-1)
    # Recall metric:
    recall_mean.append(acc.mean())
    recall_sd.append(np.std(acc))
    # AUC metric:
    auc_mean.append(auc.mean())
    auc_sd.append(np.std(auc))

# Convert results in form of pandas frame:
df_results = pd.DataFrame({"Model": [j.__class__.__name__ for j in models],
                           "Recall_mean": recall_mean,
                           "Recall_sd": recall_sd,
                           "AUC_mean": auc_mean,
                           "AUC_sd": auc_sd})

df_results = df_results.sort_values(by="Recall_mean", ascending=False).reset_index(drop=True)

# Show results:
print(df_results)

Huấn luyện lại ba mô hình này trên train data và tính AUC trên test data thì kết quả lần lượt là 0.8085, 0.8150 và 0.8202:

# Train Random Forest, GaussianNB and CatBoostClassifier:
ran.fit(X_train, y_train)
gnb.fit(X_train, y_train)
cat.fit(X_train, y_train)

# Probability:
pd_ran = ran.predict_proba(X_test)[:, 1]
pd_gnb = gnb.predict_proba(X_test)[:, 1]
pd_cat = cat.predict_proba(X_test)[:, 1]

# AUC by RandomForest and GaussianNB:
from sklearn.metrics import roc_auc_score

print(roc_auc_score(y_test, pd_ran))
print(roc_auc_score(y_test, pd_gnb))
print(roc_auc_score(y_test, pd_cat))

Profit nếu sử dụng ba mô hình này khi ngưỡng cho phân loại thay đổi nếu lãi suất là 10% (Figure 1):

# Function calculates profit with given cutoff when interest rate of 10%:

def profit_by_cutoff(cutoff, pred_prob):
    rate = 0.1
    pred_bg = (pred_prob >= cutoff).astype(int)
    gg = X_test[(y_test == 0) & (pred_bg == 0)]
    bg = X_test[(y_test == 1) & (pred_bg == 0)]
    profit = np.sum(rate * gg["AMOUNT"]) - np.sum(bg["AMOUNT"])
    return profit


def profit(cutoff):
    pro_ran = profit_by_cutoff(cutoff=cutoff, pred_prob=pd_ran)
    pro_gnb = profit_by_cutoff(cutoff=cutoff, pred_prob=pd_gnb)
    pro_cat = profit_by_cutoff(cutoff=cutoff, pred_prob=pd_cat)
    df_pro = pd.DataFrame({"Profit_RAN": [pro_ran],
                           "Profit_GNB": [pro_gnb],
                           "Profit_CAT": [pro_cat],
                           "Cutoff": [cutoff]})

    return df_pro


# If cutoff = 0.02:
profit_002 = profit(cutoff=0.02)
print(profit_002)

# Profit for the two models by a range of cutoff:
df_profit = pd.DataFrame()

for j in np.arange(0.01, 0.3, 0.005):
    df_j = profit(j)
    df_profit = df_profit.append(df_j)

import matplotlib.pyplot as plt

plt.style.use('fivethirtyeight')

plt.plot("Cutoff", "Profit_RAN", data=df_profit, label="RandomForest", lw=2)
plt.plot("Cutoff", "Profit_GNB", data=df_profit, label="GaussianNB", lw=2)
plt.plot("Cutoff", "Profit_CAT", data=df_profit, label="CatBoost", lw=2)
plt.title("Profit by Cutoff and classifier")
plt.xlabel("Cutoff")
plt.ylabel("Profit")
plt.legend()
plt.show()

Conclusion

Figure 1 chỉ ra rằng với một tổ chức hướng đến mục tiêu tối đa hóa lợi nhuận thì:

1. Tiêu chuẩn AUC quan trọng hơn Recall và do vậy AUC nên được coi là điều kiện cần đầu tiên khi lựa chọn mô hình nhằm mục đích tối đa hóa lợi nhuận. Thực vậy, Recall trung bình của GaussianNB cao hơn của Random Forest tới 63% nhưng nếu sử dụng GaussianNB thì mô hình này tạo la lợi nhuận tệ nhất tại phần lớn ngưỡng được chọn.

2. Mặc dù lợi nhuận cực đại nếu sử dụng CatBoost cao hơn lợi nhuận cực đại nếu sử dụng Random Forest nhưng rõ ràng là biến động về lợi nhuận cũng cao hơn (đồng nghĩa với bất ổn/rủi ro cao hơn). Do vậy dù Random Forest không phải là mô hình tạo ra lợi nhuận cực đại nhưng mô hình này nên được lựa chọn để làm cơ sở xét cho Credit Scoring.