定义：是一种名为回归的线性分类器，其本质是由线性回归变化而来的，一种广泛使用于分类问题中的广义回归算法，通常用于二分类问题，也可以做多分类
本质：是一个返回对数几率的，在线性数据上表现优异的分类器，它主要被应用在金融领域
数学目的：是求解能够让模型对数据拟合程度最高参数的theta的值，以此构建预测函数y(x)，然后将特征矩阵输入预测函数来计算出逻辑回归的结果y
一.linear_model.LogisticRegression
penalty & C
- penalty：可以输入‘l1’或‘l2’来指定使用哪一种正则化方式，不填写默认‘l2’。注意，若选择‘l1’正则化，参数solver仅能够使用求解方式‘liblinear’和‘saga’，若使用‘l2’正则化，参数solver中所有求解方式都可以使用
- C：正则化强度的倒数，必须是一个大于0的浮点数，不填写默认1.0，即默认正则项与损失函数的比值是1:1。C越小，损失函数就越小，模型对损失函数的惩罚越重，正则化的效力越强，参数theta会逐渐被压缩的越来越小
- L1正则化和L2正则化虽然都可以控制过拟合，但它们的效果并不相同。当正则化强度逐渐增大（即C逐渐变小），参数theta的取值会逐渐变小，但L1正则化会将参数压缩为0，L2正则化只会让参数尽量小，不会取到0
- L2正则化在加强的过程中，会尽量让每个特征对模型都有一些小的贡献，但携带信息少，对模型贡献不大的特征的参数会非常接近于0，通常来说，如果只是为了防止过拟合，选择L2正则化就足够了，但如果选择L2正则化后还是过拟合，模型在未知数据集上的效果表现很差，就可以考虑L1正则化
- 两种正则化下C的取值，都可以通过学习曲线来进行调整
max_iter
- 设置参数max_iter最大迭代次数来代替步长，帮助我们控制模型的迭代速度并适时地让模型停下。max_iter越大，代表步长越小，模型迭代时间越长，反之，则代表步长设置很大，模型迭代时间很短
solver & multi_class
- 使用参数multi_class来告诉模型，我们的预测标签是什么样的类型
- 输入‘ovr’，‘multinomial’，‘auto’来告知模型，我们要处理的分类问题的类型，默认是‘ovr’
- ovr：表示分类问题是二分类，或让模型使用‘一对多’的形式来处理多分类问题
- multinomial：表示处理多分类问题，这种输入在参数solver是liblinear时不可用
- auto：表示会根据数据的分类情况和其他参数来确定模型要处理的分类问题的类型，比如数据是二分类，或者solver的取值为liblinear，auto会默认选择ovr，反之，选择multinomial
class_weight
- 使用参数class_weight对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。该参数默认none，此模式表示自动给与数据集中的所有标签相同的权重，当误分类的代价很高的时候，我们使用balanced模式，我们只是希望对标签进行均衡的时候，什么都不填就可以解决样本不均衡问题
二.案例：用逻辑回归制作评分卡
- 在银行借贷场景中，评分卡是一种以分数形式来衡量一个客户的信用风险大小的手段，它衡量向别人借钱的人不能如期履行合同中的还本付息责任，并让借钱给别人的人造成经济损失的可能性
- 一般来说，评分卡打出的分数越高，客户的信用越好，风险越小
- 这些借钱的人，可能是个人，也可能是有需求的公司和企业
- 对于企业来说，我们按照融资主体的融资用途，分别使用企业融资模型，项目融资模型等模型
- 对于个人来说，我们有四张卡来评判个人的信用程度：A卡，B卡，C卡和F卡
- 众人常说的评分卡是指A卡，又称为申请者评级模型，主要应用于相关融资类业务中的新用户的主体评级，即判断金融机构是否应该借钱给一个新用户，如果这个人的风险太高，可以拒绝贷款
1. 导库，获取数据
在银行系统中，这个数据通常来自于其他部门的同事的收集，千万抓住给你数据的人，问 ta 各个项都是什么含义
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression as LR
data = pd.read_csv("...",index_col=0)2. 探索数据与数据预处理
#观察数据类型
data.head()
#观察数据结构
data.shape()
data.info()
#去除重复值
data.drop_duplicates(inplace=True)
#删除之后不要忘记恢复索引
data.index = range(data.shape[0])
#探索缺失值
data.isnull().sum()/data.shape[0]
#填补缺失值
data["NumberOfDependents"].fillna(int(data["NumberOfDependents"].mean()),inplace=True)
#对于某一个特征大量缺失，其它特征却很完整的情况，使用随机森林填补缺失值
def fill_missing_rf(X,Y,to_fill):
#构建新的特征矩阵和新标签
df = X.copy()
fill = df.loc[:,to_fill]
df = pd.concat([df.loc[:,df.columns != to_fill],pd.DataFrame(y)],axis=1)
#找出训练集合测试集
Ytrain = fill[fill.notnull()]
Ytest = fill[fill.isnull()]
Xtrain = df.iloc[Ytrain.index,:]
Xtest = df.iloc[Ytest.index,:]
#用随机森林回归来填补缺失值
from sklearn.ensemble import RandomForestRegressor as rfr
rfr = rfr(n_estimators=100)
rfr = rfr.fit(Xtrain,Ytrain)
Ypredict =rfr.predict(Xtest)
return Ypredict
y_pred = fill_missing_rf(X,Y,"MonthlyIncome")
#确认结果合理之后，就可以将数据覆盖了
data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"] = y_pred
#描述性统计处理异常值
#描述性统计
data.describe([0.01,0.1,0.25,0.5,0.75,0.9,0.99]).T
data = data[data.loc[:,"NumberOfTimes90DaysLate"] < 90]
#逻辑回归中使用最多的是上采样方法来平衡样本
import imblearn
from imblearn.over_sampling import SMOTE
sm = SMOTE(random_state = 42) #实例化
X,Y = sm.fit_sample(X,Y)
n_sample_ = X.shape[0]
pd.Series(y).value_counts()
n_1_sample = pd.Series(y).value_counts()[1]
n_0_sample = pd.Series(y).value_counts()[0]
#分训练集和测试集
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.index = range(model_data.shape[0])
model_data.columns = data.columns
vali_data = pd.concat([Y_vali,X_vali],axis=1)
vali_data.index = range(vali_data.shape[0])
vali_data.columns = data.columns
model_data.to_csv("...")
vali_data.to_csv("...")3. 分箱
3.1 等频分箱
'''
pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化
只能够处理一维数据，返回箱子的上限和下限
参数q：要分箱的个数
参数retbins=True来要求同时返回结构索引为样本索引，元素为分到的箱子的Series
现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限
'''
model_data["qcut"],updown = pd.qcut(model_data["age"],retbins=True,q=20)
#统计每个分箱中0和1的数量，这里使用了数据透视表的功能groupby
count_y0 = model_data[model_data["Seri2yrs"] == 0].groupby(by = "qcut").count()["Seri2yrs"]
count_y1 = model_data[model_data["Seri2yrs"] == 1].groupby(by = "qcut").count()["Seri2yrs"]
#num_bins值分别为每个区间的上界，下界，0出现的次数，1出现的次数
num_bins = [*zip(updown,updown[1:],count_y0,count_y1)]
3.2 定义WOE和IV函数
#计算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 iv3.3 卡方检验，合并箱体，画出IV曲线
num_bins_ = num_bins.copy()
import matplotlib.pyplot as plt
import scipy
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]
#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_)
axisx.append(len(num_bins_))
IV.append(get_iv(bins_df))
plt.figure()
plt.plot(axisx,IV)
plt.xticks(axisx)
plt.xlabel("number of box")
plt.ylabel("IV")
plt.show3.4 用最佳分箱个数分箱，并验证分箱结果
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_[1+1][2:]
pv = scipy.stats.chi2_contingency([x1,x2])[1]
pvs.append(pv)
i = pvs.index(max(pvs))
num_bins_[1:1+2] = [(
num_bins_[1][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,4)
bins_df = get_woe(num_bins)3.5 对所有特征进行分箱选择
#将选取最佳分箱个数的过程包装为函数
def graphforbestbin(data,X,Y,n=5,q=20,graph=True):
for i in model_data.columns[1:-1]:
graphforbestbin(model_data,i,"Seri2yrs",n=2,q=20)
#生成自动分箱的分箱区间和分箱后的IV值
for col in auto_col_bins:
bins_df = graphforbestbin(model_data,col
,"Seri2yrs"
,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_if_col[col] = bins_list4. 计算各箱的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,"Seri2yrs",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"])
#对所有特征操作可以写成
for col in bins_of_col:
model_woe[col] = pd.cut(model_data[col],bins_of_col[col]).map(woeall[col])
#将标签补充到数据中
model_woe["Seri2yrs"] = model_data["Seri2yrs"]
#这就是建模数据了
model_woe.head()5.建模与模型验证
#处理测试集
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["Seri2yrs"] = vali_data["Seri2yrs"]
vali_x = vali_woe.iloc[:,:-1]
vali_y = vali_woe.iloc[:,-1]
#建模
x = model_woe.iloc[:,:-1]
y = model_woe.iloc[:,-1]
from sklearn.linear_model import LogisticRegression as LR
lr = LR().fit(x,y)
lr.score(vali_x,vali_y)6. 制作评分卡
file = "..."
with open(file,"w") as fdata:
fdata.write("...".format(base_score))
for i,col in enumerate(x.columns):
score = woeall[col] * (-B*lr.coef_[0][1])
score.name = "score"
score.index.name = col
score.to_csv(file,header=True,mode="a")
1557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
