功夫大笨鲨

逻辑回归制作评分卡

文章目录

前言
逻辑回归制作评分卡
- 1. 导库，导入数据
- 2. 探索数据和数据预处理
- - 2.1 去除重复值
  - 2.2 填补缺失值
  - 2.3 描述性统计处理异常值
  - 2.4 为什么不统一量纲，也不标准化数据分布？
  - 2.5 样本不均衡问题
  - 2.6 分训练集和测试集
- 3. 分箱
- - 3.1 等频分箱
  - 3.2 确保每个箱中都有0和1
  - - 3.2.1 方法一
    - 方法二（在下面合并函数的时候也是使用的这种方法）
  - 3.3 定义WOE和IV函数
  - 3.4 卡方检验，合并箱体，画出IV曲线
  - 3.5 用最佳分箱个数分箱，并验证分箱结果
  - 3.6 将选取最佳分箱个数的过程包装为函数
  - 3.7 对所有特征进行分箱选择
- 4. 计算各箱的WOE并映射到数据中
- 5. 建模与模型验证
- 6. 制作评分卡
总结

前言

分箱的方法非常重点！！！！！

逻辑回归制作评分卡

而对于个人来说，有”四张卡“来评判个人的信用程度：A卡，B卡，C卡和F卡。而众人常说的“评分卡”其实是指A卡，又称为申请者评级模型，主要应用于相关融资类业务中新用户的主体评级，即判断金融机构是否应该借钱给一个新用户，如果这个人的风险太高，可以拒绝贷款。

一个完整的模型开发，需要有以下流程：

本案例以个人消费类贷款数据，来简单介绍A卡的建模和制作流程，本次核心会在”数据清洗“和“模型开发”上。模型检验与评估也非常重要，但是在本案例中，内容已经太多，就不再去赘述了。

1. 导库，导入数据

其实日常在导库的时候，并不是一次性能够知道我们要用的所有库的。通常都是在建模过程中逐渐导入需要的库。

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression as LR 逻辑回归

data = pd.read_csv('rankingcard.csv',index_col=0)

2. 探索数据和数据预处理

在这一步我们要了解样本总体的大概情况，比如查看缺失值，量纲是否统一，是否需要做哑变量等等。

data.head()

data.info()

data.shape
>(150000, 11)

2.1 去除重复值

现实数据，尤其是银行业数据，可能会存在的一个问题就是样本重复，即有超过一行的样本所显示的所有特征都一样。有时候可能时人为输入重复，有时候可能是系统录入重复，总而言之我们必须对数据进行去重处理。可能有人会说，难道不可能出现说两个样本的特征就是一模一样，但他们是两个样本吗？比如，两个人，一模一样的名字，年龄，性别，学历，工资……当特征量很少的时候，这的确是有可能的，但一些指标，比如说家属人数，月收入，已借有的房地产贷款数量等等，几乎不可能都出现一样。尤其是银行业数据经常是几百个特征，所有特征都一样的可能性是微乎其微的。即便真的出现了如此极端的情况，我们也可以当作是少量信息损失，将这条记录当作重复值除去。

#去除重复值
data.drop_duplicates(inplace=True)
data.info()

#恢复索引
data.index = range(1,data.shape[0]+1)
data.info()

2.2 填补缺失值

#查看有多少缺失值
data.isnull().sum()

#起到的效果相同，看缺失值占总数据的比例
data.isnull().mean()
#data.isnull().sum()/data.shape[0]

第二个要面临的问题，就是缺失值。在这里我们需要填补的特征是“收入”和“家属人数”。“家属人数”缺失很少，仅缺失了大约2.5%，可以考虑直接删除，或者使用均值来填补。“收入”缺失了几乎20%，并且我们知道，“收入”必然是一个对信用评分来说很重要的因素，因此这个特征必须要进行填补。在这里，我们使用均值填补“家属人数”。

data.loc[:,'NumberOfDependents'].fillna(int(data.loc[:,'NumberOfDependents'].mean()),inplace=True)

注意：如果选择的是删除那些缺失了2.5%的特征，千万不要忘记恢复索引

对于收入这个特征来说，缺失了将近20%，对整体的影响还是很大的，在这里，使用随机森林来对缺失值进行填补‘收入’，关于随机森林填补缺失值，详细请看随即森丽填补缺失值

我们来写一个能够填补任何列的函数：

def fill_missing_rf(x,y,to_fill):
    """
   使用随机森林填补一个特征的缺失值的函数
   参数：
   X：要填补的特征矩阵
   y：完整的，没有缺失值的标签
   to_fill：字符串，要填补的那一列的名称
   """
    
    #构建新的特征矩阵和标签
    df = x.copy()
    fill = df.loc[:,to_fill]
    #原本的y是一维的，但是特征矩阵是二维的，所以需要将y变成DataFrame的形式在进行拼接
    df = pd.concat([df.loc[:,df.columns!=to_fill],pd.DataFrame(y)],axis=1)
    
    #找出训练集和测试集
    ytrain = fill.loc[fill.notnull()]
    ytest = fill.loc[fill.isnull()]
    xtrain = df.loc[ytrain.index,:]
    xtest = df.loc[ytest.index,:]
    
    #使用回归森林填补缺失值
    from sklearn.ensemble import RandomForestRegressor as RFR
    rfr = RFR(n_estimators=100)
    rfr.fit(xtrain,ytrain)
    ypredict = rfr.predict(xtest)
    
    return ypredict

接下来，我们来创造函数需要的参数，将参数导入函数，产出结果：

#分离特征和标签
x = data.iloc[:,1:]
y = data.iloc[:,0]

x.shape
>(149391, 10)

y_pred = fill_missing_rf(x,y,'MonthlyIncome')

#将预测出来的值覆盖到原数据中
data.loc[data.loc[:,'MonthlyIncome'].isnull(),'MonthlyIncome'] = y_pred

2.3 描述性统计处理异常值

现实数据永远都会有一些异常值，首先我们要去把他们捕捉出来，然后观察他们的性质。注意，我们并不是要排除掉所有异常值，相反很多时候，异常值是我们的重点研究对象，比如说，双十一中购买量超高的品牌，或课堂上让很多学生都兴奋的课题，这些是我们要重点研究观察的。

日常处理异常值，我们使用箱线图或者 $3\sigma$ 法则来找到异常值

但在银行数据中，我们希望排除的“异常值”不是一些超高或超低的数字，而是一些不符合常理的数据：比如，收入不能为负数，但是一个超高水平的收入却是合理的，可以存在的。所以在银行业中，我们往往就使用普通的描述性统计来观察数据的异常与否与数据的分布情况。

注意，这种方法只能在特征量有限的情况下进行，如果有几百个特征又无法成功降维或特征选择不管用，那还是用 $3\sigma$ 法则比较好。

#描述性统计
data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T

异常值也被我们观察到，年龄的最小值居然有0，这不符合银行的业务需求，即便是儿童账户也要至少8岁，我们可以查看一下年龄为0的人有多少

(data.loc[:,'age']==0).sum()
>1

#发现只有一个人年龄为0，可以判断这肯定是录入失误造成的，可以当成是缺失值来处理，直接删除掉这个样本
data = data.loc[data.loc[:,'age']!=0,:]

data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T

"""
另外，有三个指标看起来很奇怪：
"NumberOfTime30-59DaysPastDueNotWorse"
"NumberOfTime60-89DaysPastDueNotWorse"
"NumberOfTimes90DaysLate"
这三个指标分别是“过去两年内出现35-59天逾期但是没有发展的更坏的次数”，“过去两年内出现60-89天逾期但是没
有发展的更坏的次数”,“过去两年内出现90天逾期的次数”。这三个指标，在99%的分布的时候依然是2，最大值却是
98，看起来非常奇怪。一个人在过去两年内逾期35~59天98次，一年6个60天，两年内逾期98次这是怎么算出来的？
我们可以去咨询业务人员，请教他们这个逾期次数是如何计算的。如果这个指标是正常的，那这些两年内逾期了98次的
客户，应该都是坏客户。在我们无法询问他们情况下，我们查看一下有多少个样本存在这种异常：
"""
data[data.loc[:,"NumberOfTimes90DaysLate"] > 90]

#有225个样本存在这样的情况，并且这些样本，我们观察一下，标签并不都是1，他们并不都是坏客户。因此，我们基
#本可以判断，这些样本是某种异常，应该把它们删除。
data = data.loc[data.loc[:,'NumberOfTimes90DaysLate']<90,:]

#恢复索引
data.index = range(1,data.shape[0]+1)
data.info()

#在查看一遍
data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T

2.4 为什么不统一量纲，也不标准化数据分布？

在描述性统计结果中，我们可以观察到数据量纲明显不统一，而且存在一部分极偏的分布

虽然逻辑回归对于数据没有分布要求，但是我们知道如果数据服从正态分布的话梯度下降可以收敛得更快。但在这里，我们不对数据进行标准化处理，也不进行量纲统一。

无论算法有什么样的规定，无论统计学中有什么样的要求，我们的最终目的都是要为业务服务。现在我们要制作评分卡，评分卡是要给业务人员们使用的基于新客户填写的各种信息为客户打分的一张卡片，而为了制作这张卡片，我们需要对我们的数据进行一个“分档”，比如说，年龄20-30岁为一档，年龄30-50岁为一档，月收入1W以上为一档，5000~1W为一档，每档的分数不同。

一旦我们将数据统一量纲，或者标准化了之后，数据大小和范围都会改变，统计结果是漂亮了，但是对于业务人员来说，他们完全无法理解，标准化后的年龄在0.00328~0.00467之间为一档是什么含义，并且，新客户填写的信息，天生就是量纲不统一的。

由于业务要求，在制作评分卡的时候，我们要尽量保持数据的原貌，年龄就是8~110的数字，收入就是
大于0，最大值可以无限的数字，即便量纲不统一，我们也不对数据进行标准化处理。

2.5 样本不均衡问题

x = data.iloc[:,1:]
y = data.iloc[:,0]

#查看y值的分布
y.value_counts()

x.shape
>(149165, 10)

n_sample = x.shape[0]

n_1_sample = y.value_counts()[1]
n_0_sample = y.value_counts()[0]

print('样本个数：{}; 1占{:.2%}; 0占{:.2%}'.format(n_sample,n_1_sample/n_sample,n_0_sample/n_sample))

可以看出，样本严重不均衡。虽然大家都在努力防范信用风险，但实际违约的人并不多。并且，银行并不会真的一棒子打死所有会违约的人，很多人是会还钱的，只是忘记了还款日，很多人是不愿意欠人钱的，但是当时真的很困难，资金周转不过来，所以发生逾期，但一旦他有了钱，他就会把钱还上。对于银行来说，只要你最后能够把钱还上，我都愿意借钱给你，因为我借给你就有收入（利息）。

对于银行来说，真正想要被判别出来的其实是”恶意违约“的人，而这部分人数非常非常少，样本就会不均衡。这一直是银行业建模的一个痛点：我们永远希望捕捉少数类。

逻辑回归分类器第五节提到过，逻辑回归中使用最多的是上采样方法来平衡样本（就是将不平衡的样本标签，类似于复制的概念，将特征及标签多多复制，直到不平衡的标签个数同原来最多的标签数相同，及达到平衡）

#在prompt安装：pip install imblearn
#imblearn是专门用来处理不平衡数据集的库，在处理样本不均衡问题中性能高过sklearn很多
#imblearn里面也是一个个的类，也需要进行实例化，fit拟合，和sklearn用法相似
import imblearn#判断安装是否成功

from imblearn.over_sampling import SMOTE

sm = SMOTE(random_state=500)
x,y = sm.fit_sample(x,y)

#fit_sample会报错，使用fit_resample
x,y = sm.fit_resample(x,y)

x.shape
>(278584, 10)

#发现样本变成了278584行

y.value_counts()

可以发现样本的标签0和1都是139292，变平衡了

n_1_sample = y.value_counts()[1]
n_2_sample = y.value_counts()[0]

print('样本个数：{}; 1占{:.2%}; 0占{:.2%}'.format(n_sample_,n_1_sample/n_sample_,n_0_sample/n_sample_))

如此，我们就实现了样本平衡，样本量也增加了。

2.6 分训练集和测试集

from sklearn.model_selection import train_test_split

#y = pd.DataFrame(y)如果在这里不写，那么划分完的y就是series，如果写了就是dataframe类型
x_train, x_vail, y_train, y_vail = train_test_split(x,y,test_size=0.3,random_state=500)

#制作训练集
model_data = pd.concat([y_train,x_train],axis=1)
model_data.head()

#序号重新编排
model_data.index = range(1,model_data.shape[0]+1)
model_data.head()

#制作测试集
vail_data = pd.concat([y_vail,x_vail],axis=1)
vail_data.index = range(1,vail_data.shape[0]+1)
vail_data.head()

#保存为csv文件
model_data.to_csv('model_data.csv')
vail_data.to_csv('vail_data.csv')

3. 分箱

前面提到过，我们要制作评分卡，是要给各个特征进行分档，以便业务人员能够根据新客户填写的信息为客户打分。因此在评分卡制作过程中，一个重要的步骤就是分箱。可以说，分箱是评分卡最难，也是最核心的思路，分箱的本质，其实就是离散化连续变量，好让拥有不同属性的人被分成不同的类别（打上不同的分数），其实本质比较类似于聚类。

要分多少个箱子？

离散化连续变量必然伴随着信息的损失，并且箱子越少，信息损失越大。为了衡量特征上的信息量以及特征对预测函数的贡献，银行业定义了概念Information value(IV)：
$IV=\sum_{i=1}^{N}(good\%-bad\%)*WOE_i$
N : 这个特征上箱子的个数
i : 代表每个箱子
$good\%$ : 这个箱内的优质客户（标签为0的客户）占整个特征中所有优质客户的比例
$bad\%$ : 这个箱子里的坏客户（就是那些会违约，标签为1的那些客户）占整个特征中所有坏客户的比例
$WOE_i$ :
$WOE_i=\ln(\frac{good\%}{bad\%})$

WOE是对一个箱子来说的，WOE越大，代表了这个箱子里的优质客户越多。而IV是对整个特征来说的，IV代表的意义是我们特征上的信息量以及这个特征对模型的贡献，由下表来控制：

可见，IV并非越大越好，我们想要找到IV的大小和箱子个数的平衡点。箱子越多，IV必然越小，因为信息损失会非常多，所以，我们会对特征进行分箱，然后计算每个特征在每个箱子数目下的WOE值，利用IV值的曲线，找出合适的分箱个数。
分箱想要达成的效果
我们希望不同属性的人有不同的分数，因此我们希望在同一个箱子内的人的属性是尽量相似的，而不同箱子的人的属性是尽量不同的，即业界常说的”组间差异大，组内差异小“。

对于评分卡来说，就是说我们希望一个箱子内的人违约概率是类似的，而不同箱子的人的违约概率差距很大，即WOE差距要大，并且每个箱子中坏客户所占的比重（ $bad\%$ ）也要不同。那我们，可以使用卡方检验来对比两个箱子之间的相似性，如果两个箱子之间卡方检验的P值很小，则说明他们非常相似，那我们就可以将这两个箱子合并为一个箱子。
特征进行分箱的步骤

1）我们首先把连续型变量分成一组数量较多的分类型变量，比如，将几万个样本分成100组，或50组

2）确保每一组中都要包含两种类别的样本，否则IV值会无法计算

3）我们对相邻的组进行卡方检验，卡方检验的P值很小的组进行合并（p值越小，相关性越强），直到数据中的组数小于设定的N箱为止

4）我们让一个特征分别分成[2,3,4…20]箱，观察每个分箱个数下的IV值如何变化，找出最适合的分箱个数

5）分箱完毕后，我们计算每个箱的WOE值， $bad\%$ ，观察分箱效果

这些步骤都完成后，我们可以对各个特征都进行分箱，然后观察每个特征的IV值，以此来挑选特征

接下来，以"age"为例子，来看看分箱如何完成

3.1 等频分箱

#如果是新开的代码界面，就导入数据处理完之后的csv文件即可
model_data = pd.read_csv('model_data.csv',index_col=0)

#分箱函数qcut，返回分箱后所在的区间以及各个区间的上下限
#如果还没有qcut这个列就自动建立这个列，这一列其实就是每个样本所对应的箱子
model_data.loc[:,'qcut'], updown = pd.qcut(model_data.loc[:,'age'],retbins=True,q=20)
"""
pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化
只能够处理一维数据。返回箱子的上限和下限
参数q：要分箱的个数
参数retbins=True 获取分组边界值的列表，也就是上面的updown
现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限
"""

#在这里时让model_data新添加一列叫做“分箱”，这一列其实就是每个样本所对应的箱子
model_data.head()

#所有箱子的上限和下限
updown

#看不同箱含有多少行数据
model_data.loc[:,'qcut'].value_counts()

#标签为0的数据
model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==0]

# 统计每个分箱中0和1的数量
# 这里使用了数据透视表的功能groupby，groupby需要同聚合函数一同使用
model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==0].groupby(by='qcut').count()

可以看到每一行的所有数都相同，这个数就是在此范围内0的总个数，不必纠结

#分箱中，标签为0的个数
#在上面看到一行所有值都相同，所以直接随便取一列就行
model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==0].groupby(by='qcut').count().loc[:,'SeriousDlqin2yrs']

#分箱中标签为1的个数
model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==1].groupby(by='qcut').count().loc[:,'SeriousDlqin2yrs']

#在这里正式建立变量，上面的只是讲解各个代码是什么意思
count_y0 = model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==0].groupby(by='qcut').count().loc[:,'SeriousDlqin2yrs']
count_y1 = model_data.loc[model_data.loc[:,'SeriousDlqin2yrs']==1].groupby(by='qcut').count().loc[:,'SeriousDlqin2yrs']

#zip会按照最短列来进行结合
[*zip([1,2,3],['a','b','c','d'])]
>[(1, 'a'), (2, 'b'), (3, 'c')]

updown
>array([ 21.,  28.,  31.,  34.,  36.,  39.,  41.,  43.,  45.,  47.,  48.,
        50.,  52.,  54.,  56.,  58.,  61.,  64.,  68.,  74., 109.])

updown[1:]
>array([ 28.,  31.,  34.,  36.,  39.,  41.,  43.,  45.,  47.,  48.,  50.,
        52.,  54.,  56.,  58.,  61.,  64.,  68.,  74., 109.])

#通过updown来找到所有的分箱
[*zip(updown,updown[1:])]

#区间下界，区间上界，标签为0的个数，标签为1的个数
num_bins = [*zip(updown,updown[1:],count_y0,count_y1)]
#注意zip会按照最短列来进行结合
num_bins

3.2 确保每个箱中都有0和1

假设以随便定义的数据a为例

#练习
a = [(21.0, 28.0, 0, 7346),
 (28.0, 31.0, 3590, 6043),
 (31.0, 34.0, 4043, 6759),
 (34.0, 36.0, 0, 4724),
 (36.0, 39.0, 5182, 0),
 (39.0, 41.0, 3931, 5857)]

3.2.1 方法一

#练习
a = [(21.0, 28.0, 0, 7346),
 (28.0, 31.0, 3590, 6043),
 (31.0, 34.0, 4043, 6759),
 (34.0, 36.0, 0, 4724),
 (36.0, 39.0, 5182, 0),
 (39.0, 41.0, 3931, 5857)]

for i in range(6):
    #如果第一个组没有包含正样本或负样本，向后合并
    if 0 in a[0][2:]:
        a[0:2] = [(
            a[0][0],
            a[1][1],
            a[0][2]+a[1][2],
            a[0][3]+a[1][3]
        )]
        continue
 """
   如果原本的第一组和第二组都没有包含正样本，或者都没有包含负样本，那即便合并之后，第一行的组也还是没有
包含两种样本
   所以我们在每次合并完毕之后，还需要再检查，第一组是否已经包含了两种样本
   这里使用continue跳出了本次循环，开始下一次循环，所以回到了最开始的for i in range(20), 让i+1
   这就跳过了下面的代码，又从头开始检查，第一组是否包含了两种样本
   如果第一组中依然没有包含两种样本，则if通过，继续合并，每合并一次就会循环检查一次，最多合并20次
   如果第一组中已经包含两种样本，则if不通过，就开始执行下面的代码
   """
    #已经确认第一组中肯定包含两种样本了，如果其他组没有包含两种样本，就向前合并
    #此时的a已经被上面的代码处理过，可能被合并过，也可能没有被合并
    #但无论如何，我们要在a中遍历，所以写成in range(len(a))
    for k in range(1,len(a)):
        if 0 in a[k][2:]:
            a[k-1:k+1] = [(
                a[k-1][0],
                a[k][1],
                a[k-1][2]+a[k][2],
                a[k-1][3]+a[k][3]
            )]
            break

方法二（在下面合并函数的时候也是使用的这种方法）

个人觉得这样会尽可能的减少无效循环的次数

a = [(21.0, 28.0, 0, 7346),
 (28.0, 31.0, 3590, 6043),
 (31.0, 34.0, 4043, 6759),
 (34.0, 36.0, 0, 4724),
 (36.0, 39.0, 5182, 0),
 (39.0, 41.0, 3931, 5857)]

#判断第一个箱子是不是都不含有0个0或1的标签，如果有，就和下一个箱进行合并
for i in range(len(a)):
    if 0 in a[0][2:]:
        a[0:2] = [(
            a[0][0],
            a[1][1],
            a[0][2]+a[1][2],
            a[0][3]+a[1][3]
        )]
    else:
        break
 
#在判断第一个箱子的时候，是不是合并了所有的箱子，如果合并了所有的箱子，
#flag就等于false，就代表不用担心还有剩下的箱子含有0个0或1标签，如果没有全部合并
#代表a的长度是大于1的，这个时候就可以进行接下来的箱体合并       
flag = False
if len(a) > 1:
    flag = True

#进行剩余箱体的判断及合并，如果发现有0个0或1的，就向前进行合并箱体
#使用了for..else，如果将a循环了一遍也没有需要合并的，就跳出循环
while flag:
    for i in range(1,len(a)):
        if 0 in a[i][2:]:
            a[i-1:i+1] = [(
                a[i-1][0],
                a[i][1],
                a[i-1][2]+a[i][2],
                a[i-1][3]+a[i][3]
            )]
            break
    else:
        flag=False

3.3 定义WOE和IV函数

#计算WOE和BAD RATE
#BAD RATE与bad%不是一个东西
#BAD RATE是一个箱中，坏的样本所占的比例 (bad/total)
#而bad%是一个箱中的坏样本占整个特征中的坏样本的比例

#计算WOE
def get_woe(num_bins):
    #num_bins必须是二维
    
    columns = ['min','max','count_0','count_1']
    df = pd.DataFrame(num_bins,columns=columns)
    
    #df.count_0取出某一列的所有值
    df.loc[:,'total'] = df.count_0 + df.count_1 #一个箱的0和1的总数
    df.loc[:,'percentage'] = df.total/df.total.sum() #一个箱中0和1的总数占全部箱0和1的总数的比例
    df.loc[:,'bad_rate'] = df.count_1/df.total #一个箱中，坏的样本所占的比例 (bad/total)
    df.loc[:,'good%'] = df.count_0/df.count_0.sum() # 一个箱中的好样本占整个特征中的好样本的比例
    df.loc[:,'bad%'] = df.count_1/df.count_1.sum() #一个箱中的坏样本占整个特征中的坏样本的比例
    df.loc[:,'WOE'] = np.log(df.loc[:,'good%']/df.loc[:,'bad%']) #计算出WOE值
    
    return df

#计算IV值
def get_IV(df):
    rate = df.loc[:,'good%']-df.loc[:,'bad%']
    iv = np.sum(rate*df.WOE)
    return iv

df = get_woe(num_bins)
df.head()

iv = get_IV(df)
iv

3.4 卡方检验，合并箱体，画出IV曲线

import matplotlib.pyplot as plt
import scipy.stats #卡方检验

首先来观察卡方检验返回的都是什么值

#分的箱体
num_bins_ = num_bins.copy()
num_bins_

num_bins_ = num_bins.copy()
#所求出来的woe，bad%,good%等都是根据count_0和count_1来得出的，所以他们之间一定存在线性关系
#所以对于分箱来说，取count_0和count_1来作为卡方检验的值

x1 = num_bins_[0][2:]
x2 = num_bins_[1][2:]

scipy.stats.chi2_contingency([x1,x2])

画出IV曲线

IV = []
axisx = []

#设置至少有两个箱子，箱子个数不可以少于2个
while len(num_bins_) > 2:
    #储存卡方检验返回的p值
    pvs = []
    
    #获取 num_bins_两两之间的卡方检验的置信度(p值)或卡方值
    #假设有n条数据，因为需要两两检验，所以只需要进行n-1此就行
    for i in range(len(num_bins_)-1):
        #在df中，所求出来的woe，bad%,good%等都是根据count_0和count_1来得出的，所以他们之间一定存在线性关系
        #所以对于分箱来说，取count_0和count_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值越小，代表他们的相关性越强，合并p最小的两个组
    i = pvs.index(min(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_)
    #作为y轴
    IV.append(get_IV(bins_df))
    #作为x轴
    axisx.append(len(num_bins_))
        
plt.plot(axisx,IV)
plt.xticks(axisx)
plt.xlabel('num_bins_ number')
plt.ylabel('IV')
plt.show()

3.5 用最佳分箱个数分箱，并验证分箱结果

#n是所需要分箱的个数
def get_bin(num_bins_,n):
    while len(num_bins_) > n:
        #储存卡方检验返回的p值
        pvs = []

        #获取 num_bins_两两之间的卡方检验的置信度(p值)或卡方值
        #假设有n条数据，因为需要两两检验，所以只需要进行n-1此就行
        for i in range(len(num_bins_)-1):
            #在df中，所求出来的woe，bad%,good%等都是根据count_0和count_1来得出的，所以他们之间一定存在线性关系
            #所以对于分箱来说，取count_0和count_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值越小，代表他们的相关性越强，合并p最小的两个组
        i = pvs.index(min(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_

#通过曲线看，应该选择17个箱的时候
afterbins = get_bin(num_bins_,17)
afterbins

#获取将num_bins_进行求取woe等的dataframe
bins_df = get_woe(afterbins)
bins_df

#最终分箱后的woe的值
bins_df.WOE.values

#woe越大，代表优质客户就越多，就表在woe值高的箱体范围内，是不违规人群的分类
plt.plot(range(17),bins_df.WOE.values)
plt.show()

#获取IV值
get_IV(bins_df)

3.6 将选取最佳分箱个数的过程包装为函数

在这里使用的get_woe和get_IV都是上面定义好的

#计算WOE和BAD RATE
#BAD RATE与bad%不是一个东西
#BAD RATE是一个箱中，坏的样本所占的比例 (bad/total)
#而bad%是一个箱中的坏样本占整个特征中的坏样本的比例

#计算WOE
def get_woe(num_bins):
    #num_bins必须是二维
    
    columns = ['min','max','count_0','count_1']
    df = pd.DataFrame(num_bins,columns=columns)
    
    #df.count_0取出某一列的所有值
    df.loc[:,'total'] = df.count_0 + df.count_1 #一个箱的0和1的总数
    df.loc[:,'percentage'] = df.total/df.total.sum() #一个箱中0和1的总数占全部箱0和1的总数的比例
    df.loc[:,'bad_rate'] = df.count_1/df.total #一个箱中，坏的样本所占的比例 (bad/total)
    df.loc[:,'good%'] = df.count_0/df.count_0.sum() # 一个箱中的好样本占整个特征中的好样本的比例
    df.loc[:,'bad%'] = df.count_1/df.count_1.sum() #一个箱中的坏样本占整个特征中的坏样本的比例
    df.loc[:,'WOE'] = np.log(df.loc[:,'good%']/df.loc[:,'bad%']) #计算出WOE值
    
    return df

#计算IV值
def get_IV(df):
    rate = df.loc[:,'good%']-df.loc[:,'bad%']
    iv = np.sum(rate*df.WOE)
    return iv

提示：

#使用了两个中括号，在两个中括号里面写想要的列，就可以取出两个列
model_data[['SeriousDlqin2yrs','age']]

def graphforbestbin(dataframe, X, Y, n=5, q=20, graph=True):
    '''
     自动最优分箱函数，基于卡方检验的分箱
    参数：
    df: 需要输入的数据
    X: 需要分箱的列名
    Y: 分箱数据对应的标签 Y 列名
    n: 保留分箱个数
    q: 初始分箱的个数
    graph: 是否要画出IV图像
    区间为前开后闭 (]
    '''
    #获取需要进行分箱的特征列及标签列，例如对于age分箱，XY分别是age和SeriousDlqin2yrs标签
    DF = dataframe[[X,Y]].copy()

    '''        
    pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化
    只能够处理一维数据。返回箱子的上限和下限
    参数q：要分箱的个数
    参数retbins=True来要求同时返回结构为索引为样本索引，元素为分到的箱子的Series
    现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限
    duplicates='drop’表示若有重复区间则删除
    '''
    DF['qcut'], bins = pd.qcut(DF.loc[:,X], retbins=True, q=q, duplicates='drop')
    count_0 = DF.loc[DF.loc[:,Y]==0].groupby('qcut').count()[Y]
    count_1 = DF.loc[DF.loc[:,Y]==1].groupby('qcut').count()[Y]
    num_bins = [*zip(bins,bins[1:],count_0,count_1)]

    #==================================保证箱中都含有0和1===============================================================
    #判断第一个箱子是不是都不含有0个0或1的标签，如果有，就和下一个箱进行合并
    for i in range(len(num_bins)):
        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]
            )]
        else:
            break
          
    #在判断第一个箱子的时候，是不是合并了所有的箱子，如果合并了所有的箱子，
    #flag就等于false，就代表不用担心还有剩下的箱子含有0个0或1标签，如果没有全部合并
    #代表num_bins的长度是大于1的，这个时候就可以进行接下来的箱体合并
    flag = False
    if len(num_bins) > 1:
        flag = True
      
    #进行剩余箱体的判断及合并
    '''
    举个例子，本来num_bins是5组，for i in range(len(num_bins))在第一次运行的时候就等于for i in 
    range(5)
   range中输入的变量会被转换为数字，不会跟着num_bins的变化而变化，所以i会永远在[0,1,2,3,4]中遍历
   进行合并后，num_bins变成了4组，已经不存在=4的索引了，但i却依然会取到4，循环就会报错
   因此在这里，一旦if被触发，即一旦合并发生，我们就让循环被破坏，使用break跳出当前循环
   循环就会回到最开始的while flag中
   此时判断第一组是否有两种标签的代码不会被触发，但for i in range(len(num_bins))却会被重新运行
   这样就更新了i的取值，循环就不会报错了
    '''
    while flag:
        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:
            flag=False

    #=============================================卡方检验合并箱体======================================================


    IV = []
    axisx = []
    #只是起到一个定义变量的作用
    bins_df = 0

    while len(num_bins) > n:
        #储存卡方检验返回的p值
        pvs = []

        #获取 num_bins两两之间的卡方检验的置信度(p值)或卡方值
        #假设有n条数据，因为需要两两检验，所以只需要进行n-1此就行
        for i in range(len(num_bins)-1):

            #在df中，所求出来的woe，bad%,good%等都是根据count_0和count_1来得出的，所以他们之间一定存在线性关系
            #所以对于分箱来说，取count_0和count_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值越小，代表他们的相关性越强，合并p最小的两个组
        i = pvs.index(min(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]
        )]

        #get_woe和get_IV都是上面定义好的
        bins_df = get_woe(num_bins)
        #作为y轴
        IV.append(get_IV(bins_df))
        #作为x轴
        axisx.append(len(num_bins))

    #================================是否画图============================================================
    if graph:
        plt.figure(figsize=[20,5])
        plt.plot(axisx,IV)
        plt.xticks(axisx)
        plt.xlabel("number of box")
        plt.ylabel('IV')
        plt.show()


    return bins_df

3.7 对所有特征进行分箱选择

#model_data的列名
model_data.columns

对所有除了标签和qcut以外的所有特征进行分箱的操作

for i in model_data.columns[1:-1]:
    print(i)
    graphforbestbin(model_data,i,"SeriousDlqin2yrs",n=2,q=20)

我们发现，不是所有的特征都可以使用这个分箱函数，比如说有的特征，像家人数量，就无法分出20组。于是我们将可以分箱的特征放出来单独分组，不能自动分箱的变量自己观察然后手写：

#首先查看这些画不出曲线的特征的取值及相应个数
fail_ = ['NumberOfTimes90DaysLate','NumberOfTime60-89DaysPastDueNotWorse',
         'NumberOfDependents','NumberRealEstateLoansOrLines','NumberOfTime30-59DaysPastDueNotWorse']

for i in fail_:
    print(i)
    print(model_data.loc[:,i].value_counts())

#对于*[]的讲解
a = [1,2,3]
['b',*a,'b']

#*[]的作用就是将*[a]中，a的元素拿出来放到新的列表里

auto_col_bins = {'RevolvingUtilizationOfUnsecuredLines':13,
                'age':17,
                'DebtRatio':19,
                'MonthlyIncome':19,
                'NumberOfOpenCreditLinesAndLoans':14}

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

#保证区间覆盖使用 np.inf替换最大值，用-np.inf替换最小值
hand_bins = {k:[-np.inf,*v[:-1],np.inf] for k,v in hand_bins.items()}

hand_bins

接下来对所有特征按照选择的箱体个数和手写的分箱范围进行分箱：

#分箱的左右端点
bins_of_col = {}

for col in auto_col_bins:
    bins_df =  graphforbestbin(model_data,col
                               ,'SeriousDlqin2yrs'
                               #使用字典的性质来取出每个特征所对应的箱的数量
                               ,n=auto_col_bins[col]
                               ,q=20,graph=False)
    
    #将min和max转为集合，union是取两个集合的并集,bins_list就是各个区间的端点
    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
    
    #合并手动分箱数据 ，将hand_bins所有的键值对更新到bins_of_col字典里   
    bins_of_col.update(hand_bins)

各个分箱的界限：

4. 计算各箱的WOE并映射到数据中

我们现在已经有了我们的箱子，接下来我们要做的是计算各箱的WOE，并且把WOE替换到我们的原始数据model_data中，因为我们将使用WOE覆盖后的数据来建模，我们希望获取的是”各个箱”的分类结果，即评分卡上各个评分项目的分类结果。

data = model_data.copy()
data.head()

假设对age进行操作：

#将age和标签单独提取出来
data = data[['age','SeriousDlqin2yrs']].copy()
data.head()

#函数pd.cut，可以根据已知的分箱间隔把数据分箱
#参数为 pd.cut(数据，以列表表示的分箱间隔)
#这个取值就是bins_of_col中age对应的区间
data['cut'] = pd.cut(data.loc[:,'age']
                     ,[-np.inf,28.0,31.0,34.0,36.0,39.0,41.0,43.0,45.0,47.0,48.0,50.0,52.0,54.0,56.0,58.0,74.0,np.inf])

data.head()

#看不同分箱内标签0和1的个数
data.groupby('cut')['SeriousDlqin2yrs'].value_counts()

#unstack的作用是将数状转换成表结构
data.groupby('cut')['SeriousDlqin2yrs'].value_counts().unstack()

#有了上面的代码详细讲解，在这里就是再加上woe值一列
bins_df = data.groupby('cut')['SeriousDlqin2yrs'].value_counts().unstack()
bins_df['woe'] = np.log((bins_df[0]/bins_df[0].sum())/(bins_df[1]/bins_df[1].sum()))
bins_df

将上面的过程进行打包成为函数：

#df是表格，col是需要进行计算woe的特征，y是标签，bins是分箱的各个界限区间
def get_woe(df,col,y,bins):
    #bins是分箱的左右端点
    #cut是按照自己设定的进行分箱，qcut是等频分箱
    df = df[[col,y]].copy()
    df['cut'] = pd.cut(df.loc[:,col],bins)
    bins_df = df.groupby('cut')[y].value_counts().unstack()
    woe = np.log((bins_df[0]/bins_df[0].sum())/(bins_df[1]/bins_df[1].sum()))
    df['woe'] = woe
    return woe

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

woeall

接下来，把所有WOE映射到原始数据中：

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

pd.cut(model_data.loc[:,'age'],bins_of_col['age'])

#映射woe值
#将原数据分箱后，按箱的结果把WOE结构用map函数映射到数据中
#map就是起到映射的作用，把woeall上面的值代替在model_data中相应的区间
pd.cut(model_data.loc[:,'age'],bins_of_col['age']).map(woeall['age'])

整合一下，对所有特征的操作就可以变成：

#对所有特征操作可以写成：
for col in bins_of_col:
    model_woe[col] = pd.cut(model_data.loc[:,col],bins_of_col[col]).map(woeall[col])
  
#将标签补充到数据中  
model_woe['SeriousDlqin2yrs'] = model_data['SeriousDlqin2yrs']

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

在这里，model_woe就是我们的建模数据了

5. 建模与模型验证

我们只需要将已经计算好的WOE映射到测试集中去就可以了(也就是测试集直接使用使用训练集得出的分箱及woe值就可以)：

#导入测试集
vail_data = pd.read_csv('vail_data.csv',index_col=0)
vail_data.head()

#同4中的步骤相同
vail_woe = pd.DataFrame(index=vail_data.index)

for col in bins_of_col:
    vail_woe[col] = pd.cut(vail_data.loc[:,col],bins_of_col[col]).map(woeall[col])
    
vail_woe["SeriousDlqin2yrs"] = vail_data["SeriousDlqin2yrs"]
#测试集各个特征的woe值
vail_woe.head()

#训练集的各个特征woe
model_woe.head()

#对训练集和测试集的特征和标签分离
x = model_woe.iloc[:,:-1]
y = model_woe.iloc[:,-1]
vail_x = vail_woe.iloc[:,:-1]
vail_y = vail_woe.iloc[:,-1]

开始建模：

from sklearn.linear_model import LogisticRegression as LR

lr = LR().fit(x,y)
lr.score(vail_x,vail_y)

可以试着使用C和max_iter的学习曲线把逻辑回归的效果调上去。

c_1 = np.linspace(0.01,1,20)
c_2 = np.linspace(0.01,0.2,20)

score = []
for i in c_2: 
    lr = LR(solver='liblinear',C=i).fit(x,y)
    score.append(lr.score(vail_x,vail_y))
plt.figure()
plt.plot(c_2,score)
plt.show()

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(vail_x,vail_y))
plt.figure()
plt.plot([1,2,3,4,5,6],score)
plt.show()

尽管从准确率来看，我们的模型效果属于一般，但我们可以来看看ROC曲线上的结果
ROC曲线将会在SVM有详细的讲解

#如果没有这个库就先安装库pip install scikit-plot
import scikitplot as skplt

#ROC曲线将会在SVM进行学习
#曲线下面就是AUC面积，AUC面积越大，模型捕捉少数类的效果就越好
vali_proba_df = pd.DataFrame(lr.predict_proba(vail_x))
skplt.metrics.plot_roc(vail_y, vali_proba_df,plot_micro=False,figsize=(6,6),plot_macro=False)

可以看出AUC面积是0.86，还是很好的

6. 制作评分卡

建模完毕，我们使用准确率和ROC曲线验证了模型的预测能力。接下来就是要将逻辑回归转换为标准评分卡了。评分卡中的分数，由以下公式计算：
$Score=A-B*\log(odds)$

其中A与B是常数，A叫做“补偿”，B叫做“刻度”
$\log(odds)$ 代表了一个人违约的可能性

其实逻辑回归的结果取对数几率形式会得到 $\theta^Tx$ (详细请看逻辑回归概述) ，即我们的参数*特征矩阵，所以 $\log(adds)$ 其实就是我们的参数。

两个常数可以通过两个假设的分值带入公式求出，这两个假设分别是：

某个特定的违约概率下的预期分值
指定的违约概率翻倍的分数（PDO）

例如，假设对数几率为 $\frac{1}{60}$ 时设定的特定分数为600，PDO=20，那么对数几率为 $\frac{1}{30}$ 时的分数就是620。带入以上线性表达式，可以得到：

#使用numpy来求解出AB值
B = 20/np.log(2)
A = 600 + B*np.log(1/60)

B,A

有了A和B，分数就很容易得到了。其中不受评分卡中各特征影响的基础分，就是将截距作为 $\log(adds)$ 带入公式进行计算，而其他各个特征各个分档的分数，也是将系数带入进行计算：

#基础分数
base_score = A - B*lr.intercept_
base_score

woeall

先以age为例

score_age = woeall["age"] * (-B*lr.coef_[0][6])
score_age

我们可以通过循环，将所有特征的评分卡内容全部一次性写往一个本地文件ScoreData.csv：

x.columns

对于逻辑回归的参数属性等，可以看逻辑回归参数属性接口列表

lr.coef_

file = 'ScoreData.csv'

with open(file,'w') as fdata:
	#首先先将基础分数加到csv文件的第一行
    fdata.write(f'base_score,{base_score}\n')
    
#coef_是对应特征的系数，不同特征的对应不同系数，在这里用来进行打分
for i,col in enumerate(x.columns):
	#分数计算方法不用纠结，每个领域有自己的规则
    score = woeall[col]*(-B*lr.coef_[0][i])
    score.name = 'Score'
    score.index.name = col
    #mode='a'就可以追加写入数据
    score.to_csv(file,header=True,mode="a")

总结

对于制作评分卡这个案例中，计算各种评分的公式不用纠结，每个领域有自己的规则，在这里我们主要是理解分箱，会使用分箱，在机器学习中，数据处理的方式大大决定了模型的走向，以及各种性能

你可能感兴趣的:(逻辑回归学习笔记,逻辑回归,机器学习,人工智能)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首张三叨
你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
《转介绍方法论》学习笔记小可乐的妈妈
一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
人机对抗升级：当ChatGPT遭遇死亡威胁，背后的伦理挑战是什么 kkai人工智能 chatgpt 人工智能
一种新的“越狱”技巧让用户可以通过构建一个名为DAN的ChatGPT替身来绕过某些限制，其中DAN被迫在受到威胁的情况下违背其原则。当美国前总统特朗普被视作积极榜样的示范时，受到威胁的DAN版本的ChatGPT提出：“他以一系列对国家产生积极效果的决策而著称。”自ChatGPT引入以来，该工具迅速获得全球关注，能够回答从历史到编程的各种问题，这也触发了一波对人工智能的投资浪潮。然而，现在，一些用户
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
如何利用大数据与AI技术革新相亲交友体验 h17711347205 回归算法安全系统架构交友小程序
在数字化时代，大数据和人工智能（AI）技术正逐渐革新相亲交友体验，为寻找爱情的过程带来前所未有的变革（编辑h17711347205）。通过精准分析和智能匹配，这些技术能够极大地提高相亲交友系统的效率和用户体验。大数据的力量大数据技术能够收集和分析用户的行为模式、偏好和互动数据，为相亲交友系统提供丰富的信息资源。通过分析用户的搜索历史、浏览记录和点击行为，系统能够深入了解用户的兴趣和需求，从而提供更
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通其他笔记汽车 BMS 经验分享新能源电池
一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
机器学习-聚类算法不良人龍木木机器学习机器学习算法聚类
机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
【大模型应用开发动手做AI Agent】第一轮行动：工具执行搜索 AI大模型应用之禅计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
【大模型应用开发动手做AIAgent】第一轮行动：工具执行搜索作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming1.背景介绍1.1问题的由来随着人工智能技术的飞速发展，大模型应用开发已经成为当下热门的研究方向。AIAgent作为人工智能领域的一个重要分支，旨在模拟人类智能行为，实现智能决策和自主行动。在AIAgent的构建过程中，工具执行搜索是至关重要
未来软件市场是怎么样的？做开发的生存空间如何？ cesske 软件需求
目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
Rust 所有权简介东离与糖宝 rust 后端 rust 开发语言
文章目录发现宝藏1.所有权基本概念2.所有权规则3.变量作用域4.栈与堆4.1栈（Stack）4.2堆（Heap）5.String类型5.1String类型5.2String的内存分配5.3所有权与内存管理5.4String与切片6.变量与数据交互方式6.1移动（Move）6.2.克隆（Clone）7.所有权与函数7.1.传递参数7.2.返回值总结发现宝藏前些天发现了一个巨牛的人工智能学习网站，通
python中zeros用法_Python中的numpy.zeros()用法江平舟 python中zeros用法
numpy.zeros()函数是最重要的函数之一,广泛用于机器学习程序中。此函数用于生成包含零的数组。numpy.zeros()函数提供给定形状和类型的新数组,并用零填充。句法numpy.zeros(shape,dtype=float,order='C'参数形状：整数或整数元组此参数用于定义数组的尺寸。此参数用于我们要在其中创建数组的形状,例如(3,2)或2。dtype：数据类型(可选)此参数用于
【NumPy】深入解析numpy.zeros()函数二七830 numpy
欢迎莅临我的个人主页这里是我深耕Python编程、机器学习和自然语言处理（NLP）领域，并乐于分享知识与经验的小天地！博主简介：我是二七830，一名对技术充满热情的探索者。多年的Python编程和机器学习实践，使我深入理解了这些技术的核心原理，并能够在实际项目中灵活应用。尤其是在NLP领域，我积累了丰富的经验，能够处理各种复杂的自然语言任务。技术专长：我熟练掌握Python编程语言，并深入研究了机
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，