逻辑回归评分卡制作

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt

data = pd.read_csv(r"./data/rankingcard.csv",index_col=0)
data.shape # 查看数据维度

data.info()

# 删除重复值
data.drop_duplicates(inplace=True)
# 重置索引
data.reset_index(drop=True, inplace=True)
# 查看当前数据行列
data.shape

# 查看缺少情况
data.isnull().sum()
# 填充家庭成员缺失值 ，将家庭成员缺少值全部填充为0
data['NumberOfDependents'].fillna(0, inplace=True)

def fill_missing_rf(data,name):

    from sklearn.ensemble import RandomForestRegressor
    df1 = data[data[name].isnull()]
    df2 = data[~data[name].isnull()]
    X1 = df1.drop(columns = name)
    X2 = df2.drop(columns = name)
    y = df2[name]

    RF = RandomForestRegressor(max_depth=10, ).fit(X2, y)
    return RF.predict(X1) # 返回预测值
# 对缺少部分进行重新赋值
data.loc[data['MonthlyIncome'].isnull(),'MonthlyIncome'] =fill_missing_rf(data,'MonthlyIncome')
# 检查是否还有缺少情况
data.isnull().any()

# 查看年龄分布情况
data['age'].describebe()
'''
count    149391.000000
mean         52.306237
std          14.725962
min           0.000000
25%          41.000000
50%          52.000000
75%          63.000000
max         109.000000
'''
# 统计年龄为0的个数
sum(data['age']==0) # 1
# 年龄最小值最0，不符合实际业务需求需要删出。出现这种线性很可能由于相关人员录入错误造成，无法避免。
data = data[data['age']>0]
data.reset_index(drop= True,inplace= True) # 重置索引

sum(data['NumberOfTime30-59DaysPastDueNotWorse']>90) # 这样的样本存在255个

data['NumberOfTime30-59DaysPastDueNotWorse'].value_counts() 
'''
98       220
6        140
7         54
8         25
9         12
96         5
'''
# 大于90的样本有98、96分别为220、5，这部分样本应该删除

data = data[data['NumberOfTime30-59DaysPastDueNotWorse']<95]
data.reset_index(drop= True,inplace= True) # 重置索引

# 查看正负样本占比
data['SeriousDlqin2yrs'].value_counts()
'''
0    139293
1      9873
'''

from imblearn.over_sampling import SMOTE #导入上采样 SMOTE方法 
sm = SMOTE(random_state=42) 
X,y = sm.fit_sample(X,y) #返回已经上采样完毕过后的特征矩阵和标签
# 查看样本
x.size # 278586
y.size # 278586
y.value_counts()
'''
1    139293
0    139293
'''
# 可以明显看出现在样本标签已经平衡

from sklearn.model_selection import train_test_split 

X = pd.DataFrame(X) 
y = pd.DataFrame(y) 

X_train, X_vali, Y_train, Y_vali = train_test_split(X,y,test_size=0.3,random_state=420) 

model_data = pd.concat([y_train,x_train], axis=1) # 将特征与标签进行拼接
model_data.reset_index(drop=True, inplace=True) # 重置索引

vali_data = pd.concat([y_test, x_test], axis=1)
vali_data.reset_index(drop=True, inplace=True)

# 重新保存文件, 有利于后续操作
model_data.to_csv(r"model_data.csv") 
vali_data.to_csv(r"vali_data.csv")

#按照等频对需要分箱的列进行分箱 
model_data["qcut"], updown = pd.qcut(model_data["age"], retbins=True, q=20) 
'''
pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化 
只能够处理一维数据。返回箱子的上限和下限 
参数q：要分箱的个数 
参数retbins=True来要求同时返回结构为索引为样本索引，元素为分到的箱子的Series 
现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限
'''

#在这里时让model_data新添加一列叫做“分箱”，这一列其实就是每个样本所对应的箱子 
model_data["qcut"].value_counts() 
#所有箱子的上限和下限 updown
# 统计每个分箱中0和1的数量 # 这里使用了数据透视表的功能
groupby coount_y0 = model_data[model_data["SeriousDlqin2yrs"]==0].groupby(by="qcut").count()["SeriousDlqin2yrs"]
coount_y1 = model_data[model_data["SeriousDlqin2yrs"] == 1].groupby(by="qcut").count() ["SeriousDlqin2yrs"] 
#num_bins值分别为每个区间的上界，下界，0出现的次数，1出现的次数 
num_bins = [*zip(updown,updown[1:],coount_y0,coount_y1)] 
#注意zip会按照最短列来进行结合
num_bins

#计算WOE和BAD RATE 
#BAD RATE与bad%不是一个东西 
#BAD RATE是一个箱中，坏的样本所占的比例 (bad/total)
#而bad%是一个箱中的坏样本占整个特征中的坏样本的比例 
def get_woe(num_bins): 
    # 通过 num_bins 数据计算 
    woe columns = ["min","max","count_0","count_1"] 
    df=pd.DataFrame(num_bins,columns=columns) 
    df["total"] = df.count_0 + df.count_1
    #一个箱子当中所有的样本数 
    df["percentage"] = df.total / df.total.sum()
    #一个箱子里的样本数，占所有样本的比例 
    df["bad_rate"] = df.count_1 / df.total
    #一个箱子坏样本的数量占一个箱子里边所有样本数 的比例
    df["good%"] = df.count_0/df.count_0.sum() 
    df["bad%"] = df.count_1/df.count_1.sum() 
    df["woe"] = np.log(df["good%"] / df["bad%"]) 
    return df 

#计算IV值 
def get_iv(df): 
    rate = df["good%"] - df["bad%"] 
    iv = np.sum(rate * df.woe) 
    return iv

num_bins_ = num_bins.copy() 
import matplotlib.pyplot as plt 
import scipy 
x1 = num_bins_[0][2:] 
x2 = num_bins_[1][2:]
x1,x2 
#不同的箱中的零和一的个数
pv = scipy.stats.chi2_contingency([x1,x2])[1] # 0 返回 chi2 值，1 返回 p 值。
pv
pvs = [] 
for i in range(len(num_bins_)-1): 
    x1 = num_bins_[i][2:] 
    x2 = num_bins_[i+1][2: ] 
    # 0 返回 chi2 值，1 返回 p 值。
    pv = scipy.stats.chi2_contingency([x1,x2])[1] #p值 

    # chi2 = scipy.stats.chi2_contingency([x1,x2])[0] #计算卡方值
    pvs.append(pv) pvs.index(max(pvs)) #取得最大p-value 让两个箱子合并 
    num_bins_[1:3] = [( num_bins_[1][0], num_bins_[2][1], num_bins_[1][2]+num_bins_[2][2], num_bins_[1][3]+num_bins_[2][3])] #合并第二组和第三组

#通过IV值选择箱数 
IV = [] 
axisx = [] 
while len(num_bins_) > 2: #大于设置的最低分箱个数 
    pvs = [] #获取 num_bins_两两之间的卡方检验的置信度（或卡方值） 
    for i in range(len(num_bins_)-1): 
        x1 = num_bins_[i][2:] x2 = num_bins_[i+1][2: ] # 0 返回 chi2 值，1 返回 p 值。 
        pv = scipy.stats.chi2_contingency([x1,x2])[1] #p值 
        # chi2 = scipy.stats.chi2_contingency([x1,x2])[0]#计算卡方值
        pvs.append(pv) # 通过 p 值进行处理。合并 p 值最大的两组 
        i = pvs.index(max(pvs)) 
        num_bins_[i:i+2] = [( num_bins_[i][0], num_bins_[i+1][1], num_bins_[i][2]+num_bins_[i+1][2], num_bins_[i][3]+num_bins_[i+1][3])] bins_df = get_woe(num_bins_)#计算每次循环完得到箱子的WOE axisx.append(len(num_bins_))#合并后箱的个数 IV.append(get_iv(bins_df))#计算每次循环完得到箱子的IV
plt.figure() 
plt.plot(axisx,IV) 
plt.xticks(axisx)
plt.xlabel("number of box") 
plt.ylabel("IV") plt.show() #选择转折点处，也就是下坠最快的折线点，所以这里对于age来说选择箱数为6
# 将分箱过程定义成函数 
def get_bin(num_bins_,n): 
    while len(num_bins_) > n: 
        pvs = [] 
        for i in range(len(num_bins_)-1): 
            x1 = num_bins_[i][2:] 
            x2 = num_bins_[i+1][2:] 
            pv = scipy.stats.chi2_contingency([x1,x2])[1] 
            # chi2 = scipy.stats.chi2_contingency([x1,x2])[0] 
            pvs.append(pv) 
            i = pvs.index(max(pvs)) 
            num_bins_[i:i+2] = [( num_bins_[i][0], num_bins_[i+1][1], num_bins_[i][2]+num_bins_[i+1][2], num_bins_[i][3]+num_bins_[i+1][3])] 
    return num_bins_
afterbins = get_bin(num_bins,6) 
afterbins 
bins_df = get_woe(num_bins) #查看最终分箱过后的WOE值
bins_df #希望每组的bad_rate相差越大越好；
# woe差异越大越好，应该具有单调性，随着箱的增加，要么由正到负，要么由负到正，只能有一个转折过 程；# 如果woe值大小变化是有两个转折，比如呈现w型，证明分箱过程有问题 
# num_bins保留的信息越多越好

def graphforbestbin(DF, X, Y, n,q=20,graph=True):
    '''
    自动最优分箱函数，基于卡方检验的分箱

    参数：
    DF: 需要输入的数据
    X: 需要分箱的列名
    Y: 分箱数据对应的标签 Y 列名
    n: 保留分箱个数
    q: 初始分箱的个数
    graph: 是否要画出IV图像

    区间为前开后闭 (]

    '''

    DF = DF[[X,Y]].copy()

    DF["qcut"],bins = pd.qcut(DF[X], retbins=True, q=q,duplicates="drop")
    coount_y0 = DF.loc[DF[Y]==0].groupby(by="qcut").count()[Y]
    coount_y1 = DF.loc[DF[Y]==1].groupby(by="qcut").count()[Y]
    num_bins = [*zip(bins,bins[1:],coount_y0,coount_y1)]

    #判断每个箱子是否包含正负样本
    for i in range(q):
        if 0 in num_bins[0][2:]:
            num_bins[0:2] = [(
                num_bins[0][0],
                num_bins[1][1],
                num_bins[0][2]+num_bins[1][2],
                num_bins[0][3]+num_bins[1][3])]
            continue

        for i in range(len(num_bins)):
            if 0 in num_bins[i][2:]:
                num_bins[i-1:i+1] = [(
                    num_bins[i-1][0],
                    num_bins[i][1],
                    num_bins[i-1][2]+num_bins[i][2],
                    num_bins[i-1][3]+num_bins[i][3])]
                break
        else:
            break

    #定义WOE函数
    def get_woe(num_bins):
        columns = ["min","max","count_0","count_1"]
        df = pd.DataFrame(num_bins,columns=columns)
        df["total"] = df.count_0 + df.count_1
        df["percentage"] = df.total / df.total.sum()
        df["bad_rate"] = df.count_1 / df.total
        df["good%"] = df.count_0/df.count_0.sum()
        df["bad%"] = df.count_1/df.count_1.sum()
        df["woe"] = np.log(df["good%"] / df["bad%"])
        return df

    #定义IV函数
    def get_iv(df):
        rate = df["good%"] - df["bad%"]
        iv = np.sum(rate * df.woe)
        return iv

    #找最合理的分箱数n
    IV = []
    axisx = []
    while len(num_bins) > n:
        pvs = []
        for i in range(len(num_bins)-1):
            x1 = num_bins[i][2:]
            x2 = num_bins[i+1][2:]
            pv = scipy.stats.chi2_contingency([x1,x2])[1]
            pvs.append(pv)

        i = pvs.index(max(pvs))
        num_bins[i:i+2] = [(
            num_bins[i][0],
            num_bins[i+1][1],
            num_bins[i][2]+num_bins[i+1][2],
            num_bins[i][3]+num_bins[i+1][3])]


        bins_df = pd.DataFrame(get_woe(num_bins))
        axisx.append(len(num_bins))
        IV.append(get_iv(bins_df))

    if graph:
        plt.figure()
        plt.plot(axisx,IV)
        plt.xticks(axisx)
        plt.xlabel("number of box")
        plt.ylabel("IV")
        plt.show()
    return bins_df

#可以使用分箱的特征
auto_col_bins = {"RevolvingUtilizationOfUnsecuredLines":5
                 ,
                "age":4,
                "DebtRatio":4,
                "MonthlyIncome":5,
                "NumberOfOpenCreditLinesAndLoans":5}

#不能使用自动分箱的变量
hand_bins = {"NumberOfTime30-59DaysPastDueNotWorse":[0,1,2,13]
            ,"NumberOfTimes90DaysLate":[0,1,2,17]
            ,"NumberRealEstateLoansOrLines":[0,1,2,54]
            ,"NumberOfTime60-89DaysPastDueNotWorse":[0,1,2,8]
            ,"NumberOfDependents":[0,1,2,3]}

#保证区间覆盖使用 np.inf替换最大值，用-np.inf替换最小值 
#原因：比如一些新的值出现，例如家庭人数为30，以前没出现过，改成范围为极大值之后，这些新值就都能分到箱里边了
hand_bins = {k:[-np.inf,*v[:-1],np.inf] for k,v in hand_bins.items()}
bins_of_col = {}

# 生成自动分箱的分箱区间和分箱后的 WOE值

for col in auto_col_bins:
    bins_df = graphforbestbin(model_data,col
                             ,"SeriousDlqin2yrs"
                             ,n=auto_col_bins[col]
                             #使用字典的性质来取出每个特征所对应的箱的数量
                             ,q=20
                             ,graph=False)
    bins_list = sorted(set(bins_df["min"]).union(bins_df["max"]))
    #保证区间覆盖使用 np.inf 替换最大值 -np.inf 替换最小值
    bins_list[0],bins_list[-1] = -np.inf,np.inf
    bins_of_col[col] = bins_list

# 计算woe的函数
def get_woe(df,col,y,bins):

    df = df[[col,y]].copy()
    df["cut"] = pd.cut(df[col],bins)
    bins_df = df.groupby("cut")[y].value_counts().unstack()
    woe = bins_df["woe"] = np.log((bins_df[0]/bins_df[0].sum())/(bins_df[1]/bins_df[1].sum()))
    return woe

#将所有特征的WOE存储到字典当中
woeall = {}
for col in bins_of_col:
    woeall[col] = get_woe(model_data,col,"SeriousDlqin2yrs",bins_of_col[col])

woeall
#不希望覆盖掉原本的数据，创建一个新的DataFrame，索引和原始数据model_data一模一样
model_woe = pd.DataFrame(index=model_data.index)

#将原数据分箱后，按箱的结果把WOE结构用map函数映射到数据中
model_woe["age"] = pd.cut(model_data["age"],bins_of_col["age"]).map(woeall["age"])
model_woe.head()

#对所有特征操作可以写成：
for col in bins_of_col:
    model_woe[col] = pd.cut(model_data[col],bins_of_col[col]).map(woeall[col])

#将标签补充到数据中
model_woe["SeriousDlqin2yrs"] = model_data["SeriousDlqin2yrs"]

#这就是我们的建模数据了
model_woe.head()

vali_woe = pd.DataFrame(index=vali_data.index)

for col in bins_of_col:
    vali_woe[col] = pd.cut(vali_data[col],bins_of_col[col]).map(woeall[col])
vali_woe["SeriousDlqin2yrs"] = vali_data["SeriousDlqin2yrs"]

vali_X = vali_woe.iloc[:,:-1]
vali_y = vali_woe.iloc[:,-1]
vali_X.head()

X = model_woe.iloc[:,:-1]
y = model_woe.iloc[:,-1]
X
# 使用LogisticRegression进行建模
from sklearn.linear_model import LogisticRegression as LR

lr = LR().fit(X,y)
lr.score(vali_X,vali_y)
# 找到较好的模型
c_1 = np.linspace(0.01,1,20)
c_2 = np.linspace(0.01,0.2,20)

score = []
for i in c_1:
    lr = LR(solver='liblinear',C=i).fit(X,y)
    score.append(lr.score(vali_X,vali_y))
plt.figure()
plt.plot(c_1,score)
plt.show()

lr.n_iter_ #array([7], dtype=int32)

score = []
for i in [1,2,3,4,5,6]: 
    lr = LR(solver='liblinear',C=0.025,max_iter=i).fit(X,y)
    score.append(lr.score(vali_X,vali_y))
plt.figure()
plt.plot([1,2,3,4,5,6],score)
plt.show()
# 模型评估
import scikitplot as skplt

#%%cmd
#pip install scikit-plot

vali_proba_df = pd.DataFrame(lr.predict_proba(vali_X))
skplt.metrics.plot_roc(vali_y, vali_proba_df,
                        plot_micro=False,figsize=(6,6),
                        plot_macro=False)

B = 20/np.log(2)
A = 600 + B*np.log(1/60)

B,A

base_score = A - B*lr.intercept_#lr.intercept_：截距
base_score#array([481.56390143])

file = "ScoreData.csv"

with open(file,"w") as fdata:  
    fdata.write("base_score,{}\n".format(base_score))
for i,col in enumerate(X.columns):#[*enumerate(X.columns)]
    score = woeall[col] * (-B*lr.coef_[0][i])
    score.name = "Score"
    score.index.name = col
    score.to_csv(file,header=True,mode="a")