Lending Club 貸款業務信用評分卡建模

目前，國內外對個人信用風險評估模型的研究方法，是通過用戶的歷史行為（如歷史數據的多維特征和貸款狀態是否違約）來訓練模型，通過這個模型對新增的貸款人“是否具有償還能力，是否具有償債意願”進行分析，預測貸款申請人是否會發生違約貸款。主要有兩種方法：以 Logistic 回歸模型為代表的傳統信用風險評估方法；以支持向量機、神經網絡、決策樹等機器學習理論為代表的新型信用風險評估模型。

本文『以Logistic 回歸模型建立信用評分卡模型』方法對 Lending Club  公司貸款業務進行信用卡評分建模，通過模型預測貸款人是否會違約，達到最小化風險的目的。其原理是將模型變量 WOE 編碼方式離散化之后運用 logistic 回歸模型進行的一種二分類變量的廣義線性模型。一般地，我們將模型目標標量 1 記為違約用戶，目標變量 0 記為正常用戶。

• 原始數據來源：https://www.kaggle.com/wendykan/lending-club-loan-data/kernels
• 原始時間跨度：2007-2015
• 原始數據維度：226萬 * 145
• 本項違約定義：違約16天及其以上 （d_loan = [ "Late (16-30 days)" , "Late (31-120 days)"，"Charged Off" , "Default", "Does not meet the credit policy. Status:Charged Off"]）
• 模型時間窗口：由於數據量較大，時間跨度過長，故選擇2016、2017 兩年的數據進行后續建模（數據877986*145）。 

對 Lending Club 公司業務前期分析：

• Lending Club 公司2007-2018貸款業務初步分析：https://www.cnblogs.com/Ray-0808/p/12618551.html
• Lending Club 公司2007-2018貸款業務好壞帳分析：https://www.cnblogs.com/Ray-0808/p/12668594.html

1. 數據清洗

1.1 刪除變量

1. 刪去缺失率大於 25% 變量 （44個變量）
2. 刪去取值只有一個的變量,同一性很大的變量 （17個變量）
3. 刪去一些無用變量，例如一些貸后數據，如下圖

1.2 刪除記錄缺失

• 25% 特征信息的記錄 （1條記錄）
• 剔除包含異常值的記錄

1.3 填充空值

• 缺失值標示為一類，將字符型缺失數據填充 'UnKnown'
• 眾數填充，將數值型缺失數據用眾數填充

清洗后數據量：數據877985*71

2. 數據分箱

2.1 數據分箱方法

數據分箱的方法可以分為：有監督分箱和無監督分箱。有監督分箱可以分為 Split 分箱和 Merge 分箱，無監督分箱為等頻分箱、等距分箱、聚類分箱等。
本項目使用卡方分箱法（ChiMerge），基本思想是如果兩個相鄰的區間具有類似的類分布，則這兩個區間合並；否則，它們應保持分開。
操作過程：

1. 輸入：分箱的最大區間數n
2. 初始化
   • 連續值按升序排列，離散值先轉化為壞客戶的比率，然后再按升序排列；
   • 為了減少計算量，對於狀態數大於某一閾值 (建議為100) 的變量，利用等頻分箱進行粗分箱。
   • 若有缺失值，則缺失值單獨作為一個分箱。
3. 合並區間
   • 計算每一對相鄰區間的卡方值；
   • 將卡方值最小的一對區間合並
   • 重復以上兩個步驟，直到分箱數量不大於n
4. 分箱后處理
   • 對於壞客戶比例為 0 或 1 的分箱進行合並 (一個分箱內不能全為好客戶或者全為壞客戶)。
   • 對於分箱后某一箱樣本占比超過 95% 的箱子進行刪除。
5. 輸出：分箱后的數據和分箱區間。

2.2 本項目數據划分

由於使用的卡方分箱法，分箱過程中會使用到實際違約變量（"y_label"）的數據，為防止數據泄露，需要在對數據進行分箱前划分數據集。這里由於數據傾斜（違約樣本占比遠少於正常樣本），所以使用分層抽樣的方法，避免數據分布不均。

# 分層抽樣, 避免不均
from sklearn.model_selection import StratifiedShuffleSplit
split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index, test_index in split.split(data, data.loc[:, 'y_label']):
    train_set = data.iloc[train_index, :]
    test_set = data.iloc[test_index, :]

2.3 本項目分箱流程

1. 類別型變量
   1. 當取值較少時：
      1. 如果每種類別同時包含好壞樣本，無需分箱
      2. 如果有類別只包含好壞樣本的一種，需要合並
   2. 當取值較多時，先用bad rate編碼（即將每個類別變量的不同值用其違約率代替），再用連續型分箱的方式進行分箱
2. 連續型變量
   1. 檢查是否有特殊值，需要單獨分箱
   2. 檢查原始分箱個數，如果過大，需要粗分箱（比如100箱）
   3. 使用卡方分箱法
   4. 檢查所分箱是否有箱是相同值，有則合並
   5. 檢查分箱后是否符合單調性，不單調則合並

 本部代碼較多，集中放置於附錄代碼中。

3. WOE 編碼

在分箱完畢后，需要對每個變量的各箱進行編碼，才能送入邏輯回歸模型中進行使用。
WOE的全稱是“Weight of Evidence”,計算每個變量的每箱 WOE 值，然后使用對應 WOE 值對該變量進行編碼。其不同於ONE-HOT編碼后會創建許多新變量，造成矩陣稀疏、維度災難等問題
WOE 編碼相當於把分箱后的特征從非線性可分映射到近似線性可分的空間內：

• 可提升模型的預測效果
• 將自變量規范到同一尺度上
• WOE能反映自變量取值的貢獻情況
• 有利於對變量的每個分箱進行評分
• 轉化為連續變量之后，便於分析變量與變量之間的相關性
• 與獨熱向量編碼相比，可以保證變量的完整性，同時避免稀疏矩陣和維度災難

 如 ”int_rate“ 變量：

4. 變量篩選

4.1 單變量篩選

1. 基於 IV 值的變量篩選信息價值，類似於信息增益、基尼系數
2. 基於 stepwise 的變量篩選，一步一步進行變量篩選
3. 基於特征重要度的變量篩選：RF, GBDT…
4. 基於 LASSO 正則化的變量篩選

 本文對比使用了兩種，最終選擇第一種方法。

# 4.1 單變量選擇  -->  按 IV 值挑選變量，IV > 0.02
high_IV = {k: v for k, v in IV_dict.items() if v >= 0.02}
high_IV_dict_sorted = sorted(high_IV.items(), key=lambda x: x[1], reverse=False)
high_IV_values = [i[1] for i in high_IV_dict_sorted]
high_IV_names = [i[0] for i in high_IV_dict_sorted]
feat_select_1 = []
for i in high_IV_names:
    feat_select_1.append(i + '_WOE')
print("經過 IV>0.02 挑選后，有 {} 個變量".format(len(feat_select_1)))
print("這些變量是：", feat_select_1)
fig_1, ax = plt.subplots(1, 1)
plt.barh(range(len(high_IV_values)), high_IV_values)
plt.title('feature IV')
plt.yticks(range(len(high_IV_names)), high_IV_names)
plt.savefig(folder_data + "feature_IV.png", dpi=1000, bbox_inches='tight')  # 解決圖片不清晰，不完整的問題
# plt.show()

# 4.2 單變量選擇  -->  隨機森林法選擇變量
X = train_data[WOE_feat]
X = np.matrix(X)
y = train_data['y_label']
y = np.array(y)
RFC = RandomForestClassifier()
RFC_Model = RFC.fit(X, y)
features_rfc = train_data[WOE_feat].columns
RF_feat_importance = {features_rfc[i]: RFC_Model.feature_importances_[i] for i in range(len(features_rfc))}
RF_feat_importance_sorted = sorted(RF_feat_importance.items(), key=lambda x: x[1], reverse=False)
RF_feat_values = [i[1] for i in RF_feat_importance_sorted]
RF_feat_names = [i[0] for i in RF_feat_importance_sorted]
print("經過隨機森林法單變量挑選后，有 {} 個變量".format(len(RF_feat_names)))
print("這些變量是：", RF_feat_names)
fig_2, ax = plt.subplots(1, 1)
plt.barh(range(len(RF_feat_values)), RF_feat_values)
plt.title('隨機森林特征重要性排行')
plt.yticks(range(len(RF_feat_names)), RF_feat_names)
plt.show()

4.2 變量相關性

• 雙變量相關性 線性相關性：皮爾遜相關系數
• 多變量相關性 多重共線性：某一個變量可以由其他變量線性表示，使用VIF（方差膨脹因子）檢驗

下圖變量線性相關性熱力圖：

5. 建模評價

5.1 建模

可以使用 sklearn 或者 statsmodels 等等庫調用邏輯回歸模型。

5.2 評價

		預測
		1	0
實際	1	TP（true positivie）	FN（false negative）
	0	FP（false positive）	TN（true negative）

 

• 真正率（TPR）：實際上為正例被預測為正例的比率，TPR = TP / (TP + FN)
• 假正率（FPR）：實際上為反例被預測為正例的比率，FPR = FP / (FP + TN)
• ROC 曲線：橫坐標由假正率，縱坐標由真正率構成的曲線
• AUC 值：ROC 曲線到 坐標軸之間的面積，指隨機給定一個正樣本和一個負樣本，分類器輸出該正樣本為正的那個概率值比分類器輸出該負樣本為正的那個概率值要大的可能性
• KS 值：KS = max(TPR-FPR)，大於0.2 則說明模型區分性較好

6. 參考文獻

• 邏輯回歸算法：https://www.cnblogs.com/biyeymyhjob/archive/2012/07/18/2595410.html
• 特征重要度 WoE、IV、BadRate：https://www.cnblogs.com/Allen-rg/p/11507970.html
• 隨機森林： https://www.cnblogs.com/maybe2030/p/4585705.html#top
• L1、L2：https://blog.csdn.net/jinping_shi/article/details/52433975
• 玩轉邏輯回歸之金融評分卡模型：https://zhuanlan.zhihu.com/p/36539125
• 利用LendingClub數據建模：https://zhuanlan.zhihu.com/p/21550547

 

附錄：

# coding:utf-8

import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.stats.outliers_influence import variance_inflation_factor
import pickle
from sklearn.model_selection import train_test_split
import statsmodels.api as sm
from sklearn.ensemble import RandomForestClassifier
import CustomFunction as cf
from sklearn.model_selection import StratifiedShuffleSplit

# 顯示設置
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用來正常顯示中文標簽
plt.rcParams['axes.unicode_minus'] = False  # 用來正常顯示負號,#有中文出現的情況，需要u'內容'
pd.set_option('display.max_columns', 1000)
pd.set_option('display.width', 1000)
pd.set_option('display.max_colwidth', 1000)
pd.set_option('display.max_row', 1000)

# 程序開始時間計算
start_time = time.process_time()

# 存放數據文件路徑
folder_data = r'E:/3.Python_Project/LENGING_CLUB/data/'

# ----------------------------------------------------------------------------------------------------------------------
# 0. 讀取數據 ， 轉換數據格式
# ----------------------------------------------------------------------------------------------------------------------
# loan = pd.read_csv('loan.csv', low_memory=False)
# df = loan.copy()
#
# # 將 ‘issue_d’ str形式的時間日期轉換
# dt_series = pd.to_datetime(df['issue_d'])
# df['year'] = dt_series.dt.year
# df['month'] = dt_series.dt.month
#
# # 取 2016-2017 年度的數據進行后續計算
# print(df['year'].unique())
# df = df[df['year'].isin([2016, 2017])]
# print(df['year'].unique())
#
# # 根據貸款狀態 ‘loan_status’ 定義違約標簽
# d_loan = ["Late (16-30 days)", "Late (31-120 days)", "Charged Off", "Default",
#           "Does not meet the credit policy. Status:Charged Off"]
# df['loan_condition'] = np.nan
# lst = [df]
#
#
# def loan_condition(status):
#     if status in d_loan:
#         return 'd Loan'
#     else:
#         return 'c Loan'
#
#
# df['loan_condition'] = df['loan_status'].apply(loan_condition)
# df['y_label'] = np.nan
# for col in lst:
#     col.loc[df['loan_condition'] == 'c Loan', 'y_label'] = 0  # 正常貸款
#     col.loc[df['loan_condition'] == 'd Loan', 'y_label'] = 1  # 違約貸款
# df['y_label'] = df['y_label'].astype(int)
# df.to_pickle(folder_data + "loan_1617_preprocessing.pkl")

# ----------------------------------------------------------------------------------------------------------------------
# 1. 數據清洗
# ----------------------------------------------------------------------------------------------------------------------
# df = pd.read_pickle(folder_data+"loan_1617_preprocessing.pkl")
#
# # 1.1 刪除變量
# df_na = df.isna().sum()/df.shape[0]     # 缺失率
# # 刪去缺失率大於 25% 變量
# del_var = []
# var_big_na = list(df_na[df_na>0.25].index ) # 缺失值超過 25% 的變量
# del_var.append(var_big_na)
# df.drop(var_big_na,axis=1,inplace=True)
# df_na.drop(var_big_na,axis=0,inplace=True)
# # 刪去特征只有一個的變量,同一性很大的變量
# var_same=[]
# for i in df.columns:
#     mode_value = df[i].mode()[0]
#     mode_rate = len(df[i][df[i]==mode_value]) / df.shape[0]
#     if mode_rate > 0.9:
#         var_same.append(i)
#         df.drop(i,axis=1,inplace=True)
# del_var.append(var_same)
# # 刪去自選的一些無用特特征
# var_no_use = ['sub_grade', 'emp_title', 'addr_state', 'zip_code', 'loan_condition', 'loan_status',
#               'last_pymnt_d', 'last_credit_pull_d', 'last_pymnt_amnt', 'earliest_cr_line',
#               'initial_list_status', 'title', 'issue_d', 'mths_since_recent_inq']
# del_var.append(var_no_use)
# df.drop(var_no_use,axis=1,inplace=True)
#
# # 1.2 刪除記錄
# df_na_row = df.isna().sum(axis=1)/df.shape[1]
# del_row = list(df_na_row[df_na_row>0.25].index ) # 信息缺失超過 25% 的記錄
# df.drop(del_row,axis=0,inplace=True)
#
# # 1.3 缺失值填充
# # 查看變量類型是否正確,並填充缺失值
# object_columns = df.select_dtypes(include=["object"]).columns
# numeric_columns = df.select_dtypes(exclude=["object"]).columns
# # print(df[object_columns].head())
# # print(df[numeric_columns].head())
#
# # 將字符型缺失數據填充 'UnKnown'
# df[object_columns]=df[object_columns].fillna('UnKnown')
#
# # 將數值型缺失數據用眾數填充
# for i in numeric_columns:
#     mode_value = df[i].mode()[0]
#     df[i] = df[i].fillna(mode_value)
#
# print("數據清洗后有{}個變量".format(df.shape[1]-3))
# print("數據清洗后有{}條記錄".format(df.shape[0]))
# df.to_pickle(folder_data+"loan_1617_clean.pkl")

# ----------------------------------------------------------------------------------------------------------------------
# 2. 數據分箱(ChiMerge)
# ----------------------------------------------------------------------------------------------------------------------
# 分箱之后：
# （1）不超過5箱
# （2）Bad Rate單調
# （3）每箱同時包含好壞樣本
# （4）特殊值如'UnKnown'單獨成一箱
# ----------------------------------------------------------------------------------------------------------------------
loan_clean = pd.read_pickle(folder_data + "loan_1617_clean.pkl")
# print(loan_clean.head())
# print(loan_clean.isnull().sum())
loan_clean = loan_clean[loan_clean['dti'] != -1]
data = loan_clean.loc[loan_clean['term'] == ' 36 months'].copy()
data.drop(['year', 'month', 'term'], axis=1, inplace=True)

num_features = list(data.select_dtypes(exclude=["object"]).columns)  # 數值變量
cat_features = list(data.select_dtypes(include=["object"]).columns)  # 類型變量
# print(num_features)
# print(cat_features)
#
# 划分數據集
# train_data, test_data = train_test_split(data, test_size=0.4)
# 分層抽樣, 避免不均
split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index, test_index in split.split(data, data.loc[:, 'y_label']):
    train_set = data.iloc[train_index, :]
    test_set = data.iloc[test_index, :]

# 有幾個字段的值比較少,剔除掉
train_set = train_set[~(train_set['home_ownership'] == 'NONE')]
train_set = train_set[~(train_set['purpose'].isin(['wedding', 'educational']))]
train_data = train_set.copy()
test_set = test_set[~(test_set['home_ownership'].isin(['NONE']))]
test_set = test_set[~(test_set['purpose'].isin(['wedding', 'educational']))]
test_data = test_set.copy()

# 2.1 處理類型變量
cat_more_5_feat = []  # 類型變量中超過 5 種取值的變量
cat_less_5_feat = []  # 類型變量中超過 5 種取值的變量
# a) 檢查類型變量中哪些變量取值超過5
for var in cat_features:
    value_counts = data[var].nunique()
    if value_counts > 5:
        cat_more_5_feat.append(var)
    else:
        cat_less_5_feat.append(var)

# b) 對於類型變量值分類小於5的變量，其每種類別應該包含好壞兩種樣本，如果只有其中一種樣本則需要合並
merge_bin_dict = {}  # 存放需要合並的變量，以及合並方法
for var in cat_less_5_feat:
    bin_bad_rate = cf.BinBadRate(train_data, var, 'y_label')[0]
    if min(bin_bad_rate.values()) == 0:
        print('{} 類型變量需要合並箱'.format(var))
        combine_bin = cf.MergeBin(train_data, var, 'y_label')
        merge_bin_dict[var] = combine_bin
        pass
    if max(bin_bad_rate.values()) == 1:
        print('{} 類型變量需要合並箱'.format(var))
        combine_bin = cf.MergeBin(train_data, var, 'y_label', direction='good')
        merge_bin_dict[var] = combine_bin
#
# print(merge_bin_dict)
#
# # c） 對於類型變量值分類大於5的變量，使用 badrate 編碼，放入連續型變量
# for var in cat_more_5_feat:
#     if 'UnKnown' in list(data[var].unique()):
#         encoding_df = train_data.loc[train_data[var] != 'UnKnown'].copy()
#     else:
#         encoding_df = train_data.copy()
#     bin_bad_rate = cf.BinBadRate(encoding_df, var, 'y_label')[0]
#     if 'UnKnown' in list(data[var].unique()):
#         bin_bad_rate['UnKnown'] = -1
#     new_var = var + '_BR_encoding'
#     num_features.append(new_var)
#     train_data[new_var] = train_data[var].map(lambda x: bin_bad_rate[x])
#     test_data[new_var] = test_data[var].map(lambda x: bin_bad_rate[x])
#
# # 2.2 對連續變量進行卡方分箱（chimerge）
# bin_feat = []
# for var in num_features:
#     print("請稍等，正在處理 {} 字段".format(var))
#     if -1 not in train_data[var].unique():
#         max_bin_num = 5  # 設置最大分箱數
#         split_points = cf.ChiMerge(train_data, var, 'y_label', max_bin_num=max_bin_num)
#         train_data[var + '_bin'] = train_data[var].map(lambda x: cf.AssignBin(x, split_points))
#         monotone = cf.BadRateMonotone(train_data, var + '_bin', 'y_label')
#         while not monotone:
#             max_bin_num -= 1
#             split_points = cf.ChiMerge(train_data, var, 'y_label', max_bin_num=max_bin_num)
#             train_data[var + '_bin'] = train_data[var].map(lambda x: cf.AssignBin(x, split_points))
#             monotone = cf.BadRateMonotone(train_data, var + '_bin', 'y_label')
#             # if max_bin_num == 2:
#             #     # 當分箱數為2時，必然單調,退出
#             #     break
#         new_var = var + '_bin'
#         bin_feat.append(new_var)
#         test_data[var + '_bin'] = test_data[var].map(lambda x: cf.AssignBin(x, split_points))
#     else:
#         max_bin_num = 5  # 設置最大分箱數
#         split_points = cf.ChiMerge(train_data, var, 'y_label', special_attribute=[-1], max_bin_num=max_bin_num)
#         train_data[var + '_bin'] = train_data[var].map(lambda x: cf.AssignBin(x, split_points, special_attribute=[-1]))
#         monotone = cf.BadRateMonotone(train_data, var + '_bin', 'y_label', special_attribute=[-1])
#         while not monotone:
#             max_bin_num -= 1
#             split_points = cf.ChiMerge(train_data, var, 'y_label', special_attribute=[-1], max_bin_num=max_bin_num)
#             train_data[var + '_bin'] = train_data[var].map(lambda x: cf.AssignBin(x, split_points,
#                                                                                   special_attribute=[-1]))
#             monotone = cf.BadRateMonotone(train_data, var + '_bin', 'y_label', special_attribute=[-1])
#         new_var = var + '_bin'
#         bin_feat.append(new_var)
#         test_data[var + '_bin'] = test_data[var].map(lambda x: cf.AssignBin(x, split_points, special_attribute=[-1]))
#
# train_data.to_pickle(folder_data + 'train_data_1617.pkl')
# test_data.to_pickle(folder_data + 'test_data_1617.pkl')
#
# bin_feat.sort()
# print(bin_feat)
# print(train_data.head())

# ----------------------------------------------------------------------------------------------------------------------
# 3. WOE 編碼，計算 IV
# ----------------------------------------------------------------------------------------------------------------------
train_data = pd.read_pickle(folder_data + 'train_data_1617.pkl')
test_data = pd.read_pickle(folder_data + 'test_data_1617.pkl')

# print(train_data.head())
# print(test_data.head())

num_features.remove('y_label')
for var in cat_more_5_feat:
    new_var = var + '_BR_encoding'
    num_features.append(new_var)
bin_feat = []  # bin_feat 分箱后變量
for var in num_features:
    var_bin = var + '_bin'
    bin_feat.append(var_bin)
bin_feat = bin_feat + cat_less_5_feat  # 少於5個不同值的類型變量在本例中不用合並箱，直接使用原分箱即可
bin_feat.sort()

print("經過分箱后，有 {} 個變量".format(len(bin_feat)))
print("這些變量是：", bin_feat)

# 計算每個變量分箱后的 WOE 和 IV 值
WOE_dict = {}
IV_dict = {}
for var in bin_feat:
    WOE_IV = cf.CalcWOE(train_data, var, 'y_label')
    WOE_dict[var] = WOE_IV['WOE']
    IV_dict[var] = WOE_IV['IV']

# WOE 編碼
WOE_feat = []
for var in IV_dict.keys():
    var_WOE = var + '_WOE'
    train_data[var_WOE] = train_data[var].map(WOE_dict[var])
    test_data[var_WOE] = test_data[var].map(WOE_dict[var])
    WOE_feat.append(var_WOE)

# print(train_data[WOE_feat].head())

# ----------------------------------------------------------------------------------------------------------------------
# 4. 變量選擇
# ----------------------------------------------------------------------------------------------------------------------
# 4.1 單變量選擇  -->  按 IV 值挑選變量，IV > 0.02
high_IV = {k: v for k, v in IV_dict.items() if v >= 0.02}
high_IV_dict_sorted = sorted(high_IV.items(), key=lambda x: x[1], reverse=False)
high_IV_values = [i[1] for i in high_IV_dict_sorted]
high_IV_names = [i[0] for i in high_IV_dict_sorted]

feat_select_1 = []
for i in high_IV_names:
    feat_select_1.append(i + '_WOE')
print("經過 IV>0.02 挑選后，有 {} 個變量".format(len(feat_select_1)))
print("這些變量是：", feat_select_1)

fig_1, ax = plt.subplots(1, 1, figsize=(10, 10))
plt.barh(range(len(high_IV_values[0:19])), high_IV_values[0:19], facecolor='royalblue')
plt.title('feature IV')
plt.yticks(range(len(high_IV_names[0:19])), high_IV_names[0:19])
plt.savefig(folder_data + "feature_IV.png", dpi=1000, bbox_inches='tight')  # 解決圖片不清晰，不完整的問題
# plt.show()

# 4.2 單變量選擇  -->  隨機森林法選擇變量
# X = train_data[WOE_feat]
# X = np.matrix(X)
# y = train_data['y_label']
# y = np.array(y)
#
# RFC = RandomForestClassifier()
# RFC_Model = RFC.fit(X, y)
#
# features_rfc = train_data[WOE_feat].columns
# RF_feat_importance = {features_rfc[i]: RFC_Model.feature_importances_[i] for i in range(len(features_rfc))}
# RF_feat_importance_sorted = sorted(RF_feat_importance.items(), key=lambda x: x[1], reverse=False)
# RF_feat_values = [i[1] for i in RF_feat_importance_sorted]
# RF_feat_names = [i[0] for i in RF_feat_importance_sorted]
#
# print("經過隨機森林法單變量挑選后，有 {} 個變量".format(len(RF_feat_names)))
# print("這些變量是：", RF_feat_names)
#
# fig_2, ax = plt.subplots(1, 1)
# plt.barh(range(len(RF_feat_values)), RF_feat_values)
# plt.title('隨機森林特征重要性排行')
# plt.yticks(range(len(RF_feat_names)), RF_feat_names)
# plt.show()

# 4.3 兩兩變量之間的線性相關性檢測
# 計算相關系數矩陣，並畫出熱力圖進行數據可視化
train_data_WOE = train_data[feat_select_1]
corr = train_data_WOE.corr()
# print(corr)

fig, ax = plt.subplots(figsize=(16, 16))
sns.heatmap(corr, mask=np.zeros_like(corr, dtype=np.bool), cmap=sns.diverging_palette(220, 10, as_cmap=True),
            square=True, ax=ax)
plt.savefig(folder_data + "相關性熱力圖.png", dpi=1000, bbox_inches='tight')  # 解決圖片不清晰，不完整的問題
# plt.show()

# 1，將候選變量按照IV進行降序排列
# 2，計算第i和第i+1的變量的線性相關系數
# 3，對於系數超過閾值的兩個變量，剔除IV較低的一個
deleted_index = []
cnt_vars = len(high_IV_dict_sorted)
for i in range(cnt_vars):
    if i in deleted_index:
        continue
    x1 = high_IV_dict_sorted[i][0] + "_WOE"
    for j in range(cnt_vars):
        if i == j or j in deleted_index:
            continue
        y1 = high_IV_dict_sorted[j][0] + "_WOE"
        roh = corr.loc[x1, y1]
        if abs(roh) > 0.7:
            x1_IV = high_IV_dict_sorted[i][1]
            y1_IV = high_IV_dict_sorted[j][1]
            if x1_IV > y1_IV:
                deleted_index.append(j)
            else:
                deleted_index.append(i)

feat_select_2 = [high_IV_dict_sorted[i][0] + "_WOE" for i in range(cnt_vars) if i not in deleted_index]

print("經過兩兩共線性挑選后，有 {} 個變量".format(len(feat_select_2)))
print("這些變量是：", feat_select_2)

# 4.4 多重共線性分析
x = np.matrix(train_data[feat_select_2])
VIF_list = [variance_inflation_factor(x, i) for i in range(x.shape[1])]
max_VIF = max(VIF_list)
print(max_VIF)
# 最大的VIF是 2.862878891263925，因此這一步認為沒有多重共線性
feat_select_3 = feat_select_2

print("經過多重共線性檢查后，有 {} 個變量".format(len(feat_select_3)))
print("這些變量是：", feat_select_3)

# ----------------------------------------------------------------------------------------------------------------------
# 5. 邏輯回歸模型
# ----------------------------------------------------------------------------------------------------------------------
x = train_data[feat_select_3].copy()
y = train_data['y_label']
x['intercept'] = 1.0

LR = sm.Logit(y, x).fit()
summary = LR.summary()
print(summary)
p_values = LR.pvalues
p_values_dict = p_values.to_dict()
print(p_values_dict)

# 有些變量對因變量的影響不顯著 （p_value > 0.5 or 0.1 ......） ,去除他們
feat_select_4 = feat_select_3
large_p_values_dict = {k: v for k, v in p_values_dict.items() if v >= 0.1}
large_p_values_dict = sorted(large_p_values_dict.items(), key=lambda d: d[1], reverse=True)
while len(large_p_values_dict) > 0 and len(feat_select_4) > 0:
    varMaxP = large_p_values_dict[0][0]
    if varMaxP == 'intercept':
        break
    feat_select_4.remove(varMaxP)
    y = train_data['y_label']
    x = train_data[feat_select_4]
    x['intercept'] = [1] * x.shape[0]

    LR = sm.Logit(y, x).fit()
    p_values_dict = LR.pvalues
    p_values_dict = p_values_dict.to_dict()
    large_p_values_dict = {k: v for k, v in p_values_dict.items() if v >= 0.1}
    large_p_values_dict = sorted(large_p_values_dict.items(), key=lambda d: d[1], reverse=True)

print("經過 p 值檢驗后，有 {} 個變量".format(len(feat_select_4)))
print("這些變量是：", feat_select_4)

# ----------------------------------------------------------------------------------------------------------------------
# 6.對測試值進行預測，並且計算 KS 值 和 AUC 值
# ----------------------------------------------------------------------------------------------------------------------
summary = LR.summary()
print(summary)

x_test = test_data[feat_select_4]
x_test['intercept'] = [1] * x_test.shape[0]
test_data['predict'] = LR.predict(x_test)

print(test_data[['predict', 'y_label']])
KS, AUC = cf.CalcKsAuc(test_data, 'predict', 'y_label', draw=1)
print('normalLR: KS {}, AUC {}'.format(KS, AUC))

end_time = time.process_time()
print("程序運行了 %s 秒" % (end_time - start_time))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import roc_auc_score

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用來正常顯示中文標簽
plt.rcParams['axes.unicode_minus'] = False  # 用來正常顯示負號,#有中文出現的情況，需要u'內容'

folder_data = r'E:/3.Python_Project/LENGING_CLUB/data/'

# 分箱壞賬率計算
def BinBadRate(df, col, target, grantRateIndicator=0):
    '''
    :param df: 需要計算好壞比率的數據集
    :param col: 需要計算好壞比率的特征
    :param target: 好壞標簽
    :param grantRateIndicator: 1返回總體的壞樣本率，0不返回
    :return: 每箱壞樣本率字典，每箱壞樣本df，以及總體的壞樣本率（當grantRateIndicator＝＝1時）
    '''
    data_df = df[[col, target]].copy()
    total = data_df.shape[0]
    group_df = data_df.groupby([col]).aggregate({target: ['sum', 'count']}).reset_index()
    group_df.columns = [col, 'bad_num', 'all_num']
    group_df['total_num'] = total
    group_df['bad_rate'] = group_df['bad_num'] / group_df['all_num']
    bad_rate_dict = dict(zip(group_df[col], group_df['bad_rate']))  # 每箱壞樣本率字典
    overall_bad_rate = group_df['bad_num'].sum() / total  # 總體壞樣本率
    if grantRateIndicator == 0:
        return (bad_rate_dict, group_df)
    return (bad_rate_dict, group_df, overall_bad_rate)


# 合並全為0或全為1的箱
def MergeBin(df, col, target, direction='bad'):
    '''
     :param df: 包含檢驗0％或者100%壞樣本率
     :param col: 分箱后的變量或者類別型變量。檢驗其中是否有一組或者多組沒有壞樣本或者沒有好樣本。如果是，則需要進行合並
     :param target: 目標變量，0、1表示好、壞
     :return: 返回每個變量不同值的分箱方案，是個字典
     '''
    regroup = BinBadRate(df, col, target)[1]
    if direction == 'bad':
        # 如果是合並0壞樣本率的組，則跟最小的非0壞樣本率的組進行合並
        regroup = regroup.sort_values(by='bad_rate')
    else:
        # 如果是合並0好樣本樣本率的組，則跟最小的非0好樣本率的組進行合並
        regroup = regroup.sort_values(by='bad_rate', ascending=False)

    regroup.index = range(regroup.shape[0])
    col_regroup = [[i] for i in regroup[col]]
    del_index = []

    for i in range(regroup.shape[0] - 1):
        col_regroup[i + 1] = col_regroup[i] + col_regroup[i + 1]
        del_index.append(i)
        if direction == 'bad':
            if regroup['bad_rate'][i + 1] > 0:
                break
        else:
            if regroup['bad_rate'][i + 1] < 1:
                break
    col_regroup2 = [col_regroup[i] for i in range(len(col_regroup)) if i not in del_index]
    newGroup = {}
    for i in range(len(col_regroup2)):
        for g2 in col_regroup2[i]:
            newGroup[g2] = 'Bin ' + str(i)
    return newGroup


# badrate 編碼
def BadRateEncoding(df, col, target):
    '''
    :param df: dataframe containing feature and target
    :param col: the feature that needs to be encoded with bad rate, usually categorical type
    :param target: good/bad indicator
    :return: 按照違約率 map 各字段的不同值，各自段不同值的違約率字典
    '''
    bad_rate_dict, group_df = BinBadRate(df, col, target, grantRateIndicator=0)
    bad_rate_encoded_df = df[col].map(lambda x: bad_rate_dict[x])
    return {'encoded_df': bad_rate_encoded_df, 'bad_rate_dict': bad_rate_dict}


# 對數據使用等頻粗分數據，得到切分數據
def SplitData(df, col, num_of_split, special_attribute=[]):
    '''
    :param df: 按照col排序后的數據集
    :param col: 待分箱的變量
    :param numOfSplit: 切分的組別數
    :param special_attribute: 在切分數據集的時候，某些特殊值需要排除在外
    :return: col中“切分點“的值列表
    '''
    df2 = df.copy()
    if special_attribute != []:
        df2 = df.loc[~df[col].isin(special_attribute)]
    N = df2.shape[0]
    n = int(N / num_of_split)
    split_point_index = [i * n for i in range(1, num_of_split)]
    raw_values = sorted(list(df2[col]))
    split_point = [raw_values[i] for i in split_point_index]
    split_point = sorted(list(set(split_point)))
    return split_point  # col中“切分點“右邊第一個值


# 按切分點分箱
def AssignBin(x, split_points, special_attribute=[]):
    '''
    :param x: 某個變量的某個取值
    :param split_points: 上述變量的分箱結果，用切分點表示
    :param special_attribute:  不參與分箱的特殊取值
    :return: 分箱后的對應的第幾個箱，從0開始
    for example, if split_points = [10,20,30], if x = 7, return Bin 0. If x = 35, return Bin 3
    '''
    bin_num = len(split_points) + 1
    if x in special_attribute:
        i = special_attribute.index(x) + 1
        return 'Bin_{}'.format(0 - i)
    elif x <= split_points[0]:
        return 'Bin_0'
    elif x > split_points[-1]:
        return 'Bin_{}'.format(bin_num - 1)
    else:
        for i in range(0, bin_num - 1):
            if split_points[i] < x <= split_points[i + 1]:
                return 'Bin_{}'.format(i + 1)


# 按切分點，將值進行映射，每箱里的值映射的是每箱切分點右側點的值
def AssignGroup(x, split_points):
    '''
    :param x: 某個變量的某個取值
    :param split_points: 切分點列表
    :return: x在分箱結果下的映射
    '''
    N = len(split_points)
    if x <= min(split_points):
        return min(split_points)
    elif x > max(split_points):
        return 10e10
    else:
        for i in range(N - 1):
            if split_points[i] < x <= split_points[i + 1]:
                return split_points[i + 1]


# 計算卡方值
def Chi2(df, all_col, bad_col):
    '''
    :param df: 包含全部樣本總計與壞樣本總計的數據框
    :param all_col: 全部樣本的個數
    :param bad_col: 壞樣本的個數
    :return: 卡方值
    '''
    df2 = df.copy()
    bad_rate = sum(df2[bad_col]) * 1.0 / sum(df2[all_col])  # 總體壞樣本率
    # 當全部樣本只有好或者壞樣本時，卡方值為0
    if bad_rate in [0, 1]:
        return 0
    df2['good'] = df2.apply(lambda x: x[all_col] - x[bad_col], axis=1)
    good_rate = sum(df2['good']) * 1.0 / sum(df2[all_col])  # 總體好樣本率
    # 期望壞（好）樣本個數＝全部樣本個數*平均壞（好）樣本占比

    df2['bad_expected'] = df[all_col].apply(lambda x: x * bad_rate)
    df2['good_expected'] = df[all_col].apply(lambda x: x * good_rate)
    bad_combined = zip(df2['bad_expected'], df2[bad_col])
    good_combined = zip(df2['good_expected'], df2['good'])
    bad_chi = [(i[0] - i[1]) ** 2 / i[0] for i in bad_combined]
    good_chi = [(i[0] - i[1]) ** 2 / i[0] for i in good_combined]
    chi2 = sum(bad_chi) + sum(good_chi)
    return chi2


# 卡方分箱
def ChiMerge(df, col, target, max_bin_num=5, special_attribute=[], min_bin_threshold=0):
    '''
    :param df: 包含目標變量與分箱屬性的數據框
    :param col: 需要分箱的屬性
    :param target: 目標變量，取值0或1
    :param max_bin_num: 最大分箱數。如果原始屬性的取值個數低於該參數，不執行這段函數
    :param special_attribute: 不參與分箱的屬性取值
    :param min_bin_threshold：分箱后，箱內記錄數最少的數量控制要求
    :return: 返回分箱切分點列表
    '''
    value_list = sorted(list(set(df[col])))  # 變量的值從小達到排列列表
    N_distinct = len(value_list)
    if N_distinct <= max_bin_num:  # 如果原始屬性的取值個數低於max_interval，不執行這段函數
        print("{} 變量值的種類個數小於最大分箱數".format(col))
        return value_list[:-1]
    else:
        if len(special_attribute) >= 1:
            df1 = df.loc[df[col].isin(special_attribute)]
            df2 = df.loc[~df[col].isin(special_attribute)]  # 去掉special_attribute后的df
        else:
            df2 = df.copy()
        N_distinct = len(list(set(df2[col])))

        # 步驟一: 粗分箱，通過col對數據集進行分組，求出每組的總樣本數與壞樣本數
        if N_distinct > 100:
            split_x = SplitData(df2, col, 100, special_attribute=special_attribute)
            df2['temp'] = df2.loc[:, col].map(lambda x: AssignGroup(x, split_x))
            # Assgingroup函數：每一行的數值和切分點做對比，返回原值在切分后的映射，
            # 經過map以后，生成該特征的值對象的“分箱”后的值
        else:
            df2['temp'] = df2[col]
        # 總體bad rate將被用來計算expected bad count
        (binBadRate, regroup, overallRate) = BinBadRate(df2, 'temp', target, grantRateIndicator=1)

        # 首先，每個單獨的屬性值將被分為單獨的一組
        # 對屬性值進行排序，然后兩兩組別進行合並
        value_list = sorted(list(set(df2['temp'])))
        current_bin = [[i] for i in value_list]  # 把每個箱的值打包成[[],[]]的形式

        # 步驟二：建立循環，不斷合並最優的相鄰兩個組別，直到：
        # 1，最終分裂出來的分箱數<＝預設的最大分箱數
        # 2，每箱的占比不低於預設值（可選）
        # 3，每箱同時包含好壞樣本
        # 如果有特殊屬性，那么最終分裂出來的分箱數＝預設的最大分箱數－特殊屬性的個數

        plan_bin_num = max_bin_num - len(special_attribute)
        while (len(current_bin) > plan_bin_num):  # 終止條件: 當前分箱數＝預設的分箱數
            # 每次循環時, 計算合並相鄰組別后的卡方值。具有最小卡方值的合並方案，是最優方案
            chi2_list = []
            for k in range(len(current_bin) - 1):
                temp_group = current_bin[k] + current_bin[k + 1]
                df2b = regroup.loc[regroup['temp'].isin(temp_group)]
                chi2 = Chi2(df2b, 'all_num', 'bad_num')
                chi2_list.append(chi2)
            # 把 current_bin 的值改成類似的值改成類似從[[1][2],[3]]到[[1,2],[3]]
            best_combined = chi2_list.index(min(chi2_list))  # 找到卡方值最小的進行合並
            current_bin[best_combined] = current_bin[best_combined] + current_bin[best_combined + 1]
            current_bin.remove(current_bin[best_combined + 1])

        current_bin = [sorted(i) for i in current_bin]
        split_points = [max(i) for i in current_bin[:-1]]  # 卡方分箱后的切分點

        # 檢查是否有箱沒有好或者壞樣本。如果有，需要跟相鄰的箱進行合並，直到每箱同時包含好壞樣本
        # print("程序檢查 split_points ",split_points)
        temp_bins = df2['temp'].apply(
            lambda x: AssignBin(x, split_points, special_attribute=special_attribute))  # 每個原始箱對應卡方分箱后的箱號
        df2['temp_bin'] = temp_bins
        (bin_bad_rate, regroup) = BinBadRate(df2, 'temp_bin', target)
        [min_bad_rate, max_bad_rate] = [min(bin_bad_rate.values()), max(bin_bad_rate.values())]

        while min_bad_rate == 0 or max_bad_rate == 1:
            # 找出全部為好／壞樣本的箱
            bin_0_1 = regroup.loc[regroup['bad_rate'].isin([0, 1]), 'temp_bin'].tolist()
            bin = bin_0_1[0]

            # 如果是最后一箱，則需要和上一個箱進行合並，也就意味着分裂點split_points中的最后一個需要移除
            if bin == max(regroup.temp_bin):
                split_points = split_points[:-1]
            # 如果是第一箱，則需要和下一個箱進行合並，也就意味着分裂點split_points中的第一個需要移除
            elif bin == min(regroup.temp_bin):
                split_points = split_points[1:]
            # 如果是中間的某一箱，則需要和前后中的一個箱進行合並，依據是較小的卡方值
            else:
                current_index = list(regroup.temp_bin).index(bin)
                # 和前一箱進行合並，並且計算卡方值
                prev_index = list(regroup.temp_bin)[current_index - 1]
                df3 = df2.loc[df2['temp_bin'].isin([prev_index, bin])]
                (bin_bad_rate, df2b) = BinBadRate(df3, 'temp_bin', target)
                chi2_1 = Chi2(df2b, 'all_num', 'bad_num')

                later_index = list(regroup.temp_bin)[current_index + 1]
                df3b = df2.loc[df2['temp_bin'].isin([later_index, bin])]
                (binBadRate, df2b) = BinBadRate(df3b, 'temp_bin', target)
                chi2_2 = Chi2(df2b, 'all_num', 'bad_num')
                # 和后一箱進行合並，並且計算卡方值
                if chi2_1 < chi2_2:
                    split_points.remove(split_points[current_index - 1])
                else:
                    split_points.remove(split_points[current_index])

            # 完成合並之后，需要再次計算新的分箱准則下，每箱是否同時包含好壞樣本
            temp_bins = df2['temp'].apply(lambda x: AssignBin(x, split_points, special_attribute=special_attribute))
            df2['temp_bin'] = temp_bins
            (bin_bad_rate, regroup) = BinBadRate(df2, 'temp_bin', target)
            [min_bad_rate, max_bad_rate] = [min(bin_bad_rate.values()), max(bin_bad_rate.values())]

        # 需要檢查分箱后的箱數含量最小占比
        if min_bin_threshold > 0:
            temp_bins = df2['temp'].apply(lambda x: AssignBin(x, split_points, special_attribute=special_attribute))
            df2['temp_bin'] = temp_bins
            bin_counts = temp_bins.bin_counts().to_frame()
            bin_counts['pcnt'] = bin_counts['temp'].apply(lambda x: x * 1.0 / sum(bin_counts['temp']))
            bin_counts = bin_counts.sort_index()
            min_pcnt = min(bin_counts['pcnt'])
            while min_pcnt < min_bin_threshold and len(split_points) > 2:
                # 找出占比最小的箱
                index_of_min_pcnt = bin_counts[bin_counts['pcnt'] == min_pcnt].index.tolist()[0]
                # 如果占比最小的箱是最后一箱，則需要和上一個箱進行合並，也就意味着分裂點split_points中的最后一個需要移除
                if index_of_min_pcnt == max(bin_counts.index):
                    split_points = split_points[:-1]
                # 如果占比最小的箱是第一箱，則需要和下一個箱進行合並，也就意味着分裂點split_points中的第一個需要移除
                elif index_of_min_pcnt == min(bin_counts.index):
                    split_points = split_points[1:]
                # 如果占比最小的箱是中間的某一箱，則需要和前后中的一個箱進行合並，依據是較小的卡方值
                else:
                    # 和前一箱進行合並，並且計算卡方值
                    current_index = list(bin_counts.index).index(index_of_min_pcnt)
                    prev_index = list(bin_counts.index)[current_index - 1]
                    df3 = df2.loc[df2['temp_bin'].isin([prev_index, index_of_min_pcnt])]
                    (bin_bad_rate, df2b) = BinBadRate(df3, 'temp_bin', target)
                    chi2_1 = Chi2(df2b, 'all_num', 'bad_num')

                    # 和后一箱進行合並，並且計算卡方值
                    later_index = list(bin_counts.index)[current_index + 1]
                    df3b = df2.loc[df2['temp_bin'].isin([later_index, index_of_min_pcnt])]
                    (bin_bad_rate, df2b) = BinBadRate(df3b, 'temp_bin', target)
                    chi2_2 = Chi2(df2b, 'all_num', 'bad_num')

                    if chi2_1 < chi2_2:
                        split_points.remove(split_points[current_index - 1])
                    else:
                        split_points.remove(split_points[current_index])

                temp_bins = df2['temp'].apply(lambda x: AssignBin(x, split_points, special_attribute=special_attribute))
                df2['temp_bin'] = temp_bins
                bin_counts = temp_bins.bin_counts().to_frame()
                bin_counts['pcnt'] = bin_counts['temp'].apply(lambda x: x * 1.0 / sum(bin_counts['temp']))
                bin_counts = bin_counts.sort_index()
                min_pcnt = min(bin_counts['pcnt'])

        split_points = special_attribute + split_points

        return split_points


# 判斷某變量的壞樣本率是否單調
def BadRateMonotone(df, col, target, special_attribute=[]):
    '''
    :param df: 包含檢驗壞樣本率的變量，和目標變量
    :param col: 需要檢驗壞樣本率的變量
    :param target: 目標變量，0、1表示好、壞
    :param special_attribute: 不參與檢驗的特殊值
    :return: 壞樣本率單調與否
    '''

    special_bin = ['Bin_{}'.format(i) for i in special_attribute]  # 填充未知變量 Unknown 所在分箱
    df2 = df.loc[~df[col].isin(special_bin)]
    if len(set(df2[col])) <= 2:
        return True
    bin_bad_rate, regroup = BinBadRate(df2, col, target)
    bad_rate = [bin_bad_rate[i] for i in sorted(bin_bad_rate)]
    # 嚴格單調遞增
    if all(bad_rate[i] < bad_rate[i + 1] for i in range(len(bad_rate) - 1)):
        return True
    # 嚴格單調遞減
    elif all(bad_rate[i] > bad_rate[i + 1] for i in range(len(bad_rate) - 1)):
        return True
    else:
        return False


# 計算變量的 WOE 值 和 IV 值
def CalcWOE(df, col, target):
    '''
    :param df: 包含需要計算WOE的變量和目標變量
    :param col: 需要計算WOE、IV的變量，必須是分箱后的變量，或者不需要分箱的類別型變量
    :param target: 目標變量，0、1表示好、壞
    :return: 返回WOE字典和IV值
    '''
    total = df.groupby([col])[target].count()
    total = pd.DataFrame({'total': total})
    bad = df.groupby([col])[target].sum()
    bad = pd.DataFrame({'bad': bad})
    regroup = total.merge(bad, left_index=True, right_index=True, how='left')
    regroup.reset_index(level=0, inplace=True)
    N = sum(regroup['total'])
    B = sum(regroup['bad'])
    regroup['good'] = regroup['total'] - regroup['bad']
    G = N - B
    regroup['bad_pcnt'] = regroup['bad'].map(lambda x: x * 1.0 / B)
    regroup['good_pcnt'] = regroup['good'].map(lambda x: x * 1.0 / G)
    regroup['WOE'] = regroup.apply(lambda x: np.log(x.good_pcnt * 1.0 / x.bad_pcnt), axis=1)
    WOE_dict = regroup[[col, 'WOE']].set_index(col).to_dict(orient='index')
    for k, v in WOE_dict.items():
        WOE_dict[k] = v['WOE']
    IV = regroup.apply(lambda x: (x.good_pcnt - x.bad_pcnt) * np.log(x.good_pcnt * 1.0 / x.bad_pcnt), axis=1)
    IV = sum(IV)
    return {"WOE": WOE_dict, 'IV': IV}


# 計算 KS 值
def CalcKsAuc(data, var_col, y_col, draw=True):
    '''
    :param df: 包含目標變量與預測值的數據集
    :param score: 得分或者概率
    :param target: 目標變量
    :return: KS值 和 AUC值
    '''
    temp_df = pd.crosstab(data[var_col], data[y_col])
    KS_df = temp_df.cumsum(axis=0) / temp_df.sum()
    KS_df['KS'] = abs(KS_df[0] - KS_df[1])
    KS_df.columns = ['TPR', 'FPR', 'KS']
    KS = KS_df['KS'].max()
    KS_df = KS_df.reset_index()
    AUC = roc_auc_score(data[y_col], data[var_col])

    if draw:
        fig, ax = plt.subplots(1, 2,figsize=(20,10))
        KS_down = float(KS_df.loc[KS_df['KS'] == KS, 'FPR'])
        KS_up = float(KS_df.loc[KS_df['KS'] == KS, 'TPR'])
        KS_x = float(KS_df.loc[KS_df['KS'] == KS, 'predict'])
        ax[0].plot(KS_df['predict'], KS_df['FPR'], 'royalblue')
        ax[0].plot(KS_df['predict'], KS_df['TPR'], 'darkorange')
        ax[0].plot(KS_df['predict'], KS_df['KS'], 'mediumseagreen')
        ax[0].plot([KS_x, KS_x], [KS_down, KS_up], '--r')
        ax[0].text(0.2, 0.1, 'max(KS) = {}'.format(KS))
        ax[0].set_title("KS 曲線", fontsize=14)
        ax[0].set_xlabel("", fontsize=12)
        ax[0].set_ylabel("", fontsize=12)
        ax[0].legend()

        ax[1].plot(KS_df['FPR'], KS_df['TPR'], 'royalblue')
        ax[1].plot([0, 1], [0, 1], '--r')
        ax[1].set_title("ROC 曲線", fontsize=14)
        ax[1].fill_between(KS_df['FPR'], 0, KS_df['TPR'], facecolor='mediumseagreen', alpha=0.2)
        ax[1].text(0.6, 0.1, 'AUC = {}'.format(AUC))
        ax[1].set_xlabel("False positive rate", fontsize=12)
        ax[1].set_ylabel("True positive rate", fontsize=12)
        plt.savefig(folder_data + "KS&AUC.png", dpi=1000, bbox_inches='tight')  # 解決圖片不清晰，不完整的問題
        # plt.show()
    return KS, AUC