【金融风控-贷款违约预测】数据挖掘学习：4.建模与调参

最新推荐文章于 2022-03-02 21:29:20 发布

nano-

最新推荐文章于 2022-03-02 21:29:20 发布

阅读量1.4k

点赞数 2

分类专栏：数据挖掘文章标签：数据挖掘

本文链接：https://blog.csdn.net/qq_38235178/article/details/108742415

版权

数据挖掘专栏收录该内容

5 篇文章 1 订阅

订阅专栏

学习目标

学习在金融风控领域常用的机器学习模型；
学习机器学习模型的建模过程与调参流程；

内容介绍

逻辑回归模型：
- 理解逻辑回归模型；
- 逻辑回归模型的应用；
- 逻辑回归的优缺点；
树模型：
- 理解树模型；
- 树模型的应用；
- 树模型的优缺点；
集成模型
- 基于bagging思想的集成模型；
- 随机森林模型；
- 基于boosting思想的集成模型；
  - XGBoost模型；
  - LightGBM模型；
  - CatBoost模型；
模型对比与性能评估：
- 回归模型/树模型/集成模型；
- 模型评估方法；
- 模型评价结果；
模型调参：
- 贪心调参方法；
- 网格调参方法；
- 贝叶斯调参方法；

模型相关原理介绍

逻辑回归模型

https://blog.csdn.net/qq_38235178/article/details/108058076

决策树模型

https://blog.csdn.net/qq_38235178/article/details/108096106

GBDT模型

CART回归树

GBDT是一个集成模型，可以看做是很多个基模型的线性相加，其中的基模型就是CART回归树。

CART树是一个决策树模型，与普通的ID3，C4.5相比，CART树的主要特征是，他是一颗二分树，每个节点特征取值为“是”和“不是”。举个例子，在ID3中如果天气是一个特征，那么基于此的节点特征取值为“晴天”、“阴天”、“雨天”，而CART树中就是“不是晴天”与“是晴天”。

这样的决策树递归的划分每个特征，并且在输入空间的每个划分单元中确定唯一的输出。

回归树生成

输入：训练数据集 $D = \left \{ \left ( x_{1},y_{1} \right ),\left ( x_{2},y_{2} \right ),\cdots ,\left ( x_{n},y_{n} \right ) \right \}$

输出：一颗回归树 $f\left ( x \right ) = \sum_{m=1}^{M} \hat{c}_{m} I\left ( x\in R_{m} \right )$

一个回归树对应输入空间的一个划分，假设已经将输入空间划分为M个单元 $R_{1},R_{2},\cdots ,R_{m}$ ，并且每个单元都有固定的输出值 $\hat{c} _{m}$ ，其中I为判别函数。

当输入空间确定时，可以用平方误差来表示回归树在训练数据上的预测误差：

$loss = \sum_{x_{i}\in R_{m} }\left ( y_{i}-f\left ( x_{i} \right ) \right ) ^{2}$

则知道单元 $R_{m}$ 上的最优输出值就是 $R_{m}$ 内所有样本 $x_{i}$ 对应 $y_{i}$ 的均值。

问题是如何对输入空间进行划分？这里和决策树一样，选择的是遍历所有特征，选择最优的特征作为划分，具体的方法是选择第j个变量 $x ^{j}$ 和它的取值s作为切分变量与切分点，并定义两个区域：

$R_{1} = \left \{ x\mid x^{j}= s \right \} \ \ AND \ \ R_{2} = \left \{ x\mid x^{j}\ne s \right \}$

如果特征是连续变量，那么方法可以是：

$R_{1} = \left \{ x\mid x^{j}\le s \right \} \ \ AND \ \ R_{2} = \left \{ x\mid x^{j}> s \right \}$

然后寻找最优的变量j和最优切分点s，具体的求解：

$\min_{j,s} \left [ \min_{c1}\sum_{x_{i}\in R_{1} }\left ( y_{i}-c_{1} \right )^{2} + \min_{c2}\sum_{x_{i}\in R_{2} }\left ( y_{i}-c_{2} \right )^{2} \right ]$

其实就是遍历所有j，s找到本次的最佳划分区域了。然后对每个区域递归这个划分过程，直到满足条件为止。

回归树剪枝

根据奥卡姆剃刀原理，为了使模型有更准确的预测，我们要让模型变得尽量简单，对于决策树来说就是要做剪枝处理。

剪枝的损失函数可以如下表示：

$C_{a} \left ( T \right ) = C\left ( T \right ) + \alpha \left | T \right |$

其中 $C\left ( T \right )$ 为对训练数据的误差， $\left | T \right |$ 为树的节点数量，其中 $\alpha$ 类似于一个turning parameter，调节的是到底要精准度还是要模型的简单性。（过拟合与欠拟合）

具体的算法如下，先从整体树 $T_{0}$ 开始，对内部任意节点t，比较以t作为单节点树的损失与t作为根节点树的损失，如果单节点比下面一棵树还要好，就给剪掉。剪完后的树继续重复此过程。

GBDT模型

GBDT模型是一个集成模型，是很多CART树的线性相加。

GBDT模型可以表示为以下形式，我们约定 $f_{t}\left ( x \right )$ 表示第t轮的模型， $h_{t} \left ( x \right )$ 表示第t颗决策树，模型定义如下：

$f_{t}\left ( x \right ) =\sum_{t=1}^{T} h_{t} \left ( x \right )$

提升树采用前向分步算法。第t步的模型由第t-1步的模型形成，可以写成：

$f_{t}\left ( x \right ) = f_{t-1}\left ( x \right ) + h_{t} \left ( x \right )$

损失函数自然定义为这样的：

$L\left ( f_{t}\left ( x \right ),y \right ) = L\left ( f_{t-1}\left ( x \right ) + h_{t} \left ( x \right ) ,y \right )$

虽然整体思路都挺清晰的，但是怎么确定第t步该加上一颗什么样的树确是个大问题。针对这个问题， Freidman提出了用损失函数的负梯度来拟合本轮损失的近似值，进而拟合一个CART回归树。即每次需要拟合的是模型的负梯度。第t轮的第i个样本的损失函数的负梯度表示为:

$r_{t,i}=-\left [ \frac{\partial L\left ( f_{t}\left ( x_{i} \right ),y \right ) }{\partial f_{t}\left ( x_{i} \right )} \right ] =y_{i} -f_{m-1} \left ( x_{i} \right )$

利用 $\left ( x_{i},r_{t,i} \right )$ 其中 $i=1,2,\cdots ,m$ ,我们可以拟合一颗CART回归树，得到了第t颗回归树，其对应的叶节点区域 $R_{t,j},j=1, 2,\cdots ,J$ 。其中J为叶子节点的个数。

针对每一个叶子节点里的样本，我们求出使损失函数最小，也就是拟合叶子节点最好的的输出值 $c_{t,j}$ 如下(注意这里的 $y_{i}$ 是真实值，不是残差)：

$c_{t,j} = argmin\sum_{x_{i}\in R_{t,j}}L\left ( f_{t-1}\left ( x_{i} \right )+c,y_{i} \right )$

此时本轮的决策树拟合函数就得到了：

$h_{t} \left ( x \right ) = \sum_{j=1}^{J} c_{t,j} I\left ( x\in R_{t,j} \right )$

然后本轮的强学习器也就得到了：

$f_{t}\left ( x \right ) = f_{t-1}\left ( x \right ) + \sum_{j=1}^{J} c_{t,j} I\left ( x\in R_{t,j} \right )$

之后一直迭代下去，直到损失函数收敛即可。

XGBoost模型

https://blog.csdn.net/wuzhongqiang/article/details/104854890

Xgboost的基本原理

如果boosting算法每一步的弱分类器生成都是依据损失函数的梯度方向，则称之为梯度提升(Gradient boosting)，XGBoost算法是采用分步前向加性模型，只不过在每次迭代中生成弱学习器后不再需要计算一个系数，XGBoost 是由 k 个基模型组成的一个加法运算式：

$\hat{y} _{i} =\sum_{t=1}^{k} f_{t} \left ( x_{i} \right )$

其中 $f_{t}$ 为第t个基模型， $\hat{y} _{i}$ 为第i个样本的预测值。

那么损失函数可由预测值 $\hat{y} _{i}$ 与真实值 $y _{i}$ 进行表示：

$L=\sum_{i=1}^{n} l\left ( \hat{y} _{i},y _{i} \right )$

其中n为样本数量。

XGBoost算法通过优化结构化损失函数（加入了正则项的损失函数，可以起到降低过拟合的风险）来实现弱学习器的生成，并且XGBoost算法没有采用搜索方法，而是直接利用了损失函数的一阶导数和二阶导数值，并通过预排序、加权分位数等技术来大大提高了算法的性能。

LightGBM模型

https://blog.csdn.net/wuzhongqiang/article/details/105350579

Lightgbm，基本上就是围绕着快进行的，为了实现这个目的，lightgbm基于xgboost做了很多的优化，首先，从寻找最优分裂点上，使用直方图算法可以降低分裂点的数量，然后lightgbm的两大亮点技术是GOSS（为了降低样本的数量）和EFB（减少特征的数量）。这样从这三个角度lightgbm降低了xgboost在寻找最优分裂点上的复杂度，从而实现了快。然后Lightgbm又从树的生长策略上对xgboost进行了优化，使用了Leaf-wise实现了高精度。最后工程上Lightgbm首次支持类别特征，并且在并行方式上也做了很多的优化，然后就是提高了cache的命中率，这些方式都提高了lightgbm的训练速度。

lightgbm的优点：

内存更小
- XGBoost 使用预排序后需要记录特征值及其对应样本的统计值的索引，而 LightGBM 使用了直方图算法将特征值转变为 bin 值，且不需要记录特征到样本的索引，将空间复杂度从 O(2*#data) 降低为 O(#bin) ，极大的减少了内存消耗；
- LightGBM 采用了直方图算法将存储特征值转变为存储 bin 值，降低了内存消耗；
- LightGBM 在训练过程中采用互斥特征捆绑算法减少了特征数量，降低了内存消耗。
速度更快
- LightGBM 采用了直方图算法将遍历样本转变为遍历直方图，极大的降低了时间复杂度；
- LightGBM 在训练过程中采用单边梯度算法过滤掉梯度小的样本，减少了大量的计算；
- LightGBM 采用了基于 Leaf-wise 算法的增长策略构建树，减少了很多不必要的计算量；
- LightGBM 采用优化后的特征并行、数据并行方法加速计算，当数据量非常大的时候还可以采用投票并行的策略；
- LightGBM 对缓存也进行了优化，增加了 Cache hit 的命中率。

Catboost模型

https://mp.weixin.qq.com/s/xloTLr5NJBgBspMQtxPoFA

CatBoost是一种基于对称决策树（oblivious trees）为基学习器实现的参数较少、支持类别型变量和高准确性的GBDT框架，主要解决的痛点是高效合理地处理类别型特征，这一点从它的名字中可以看出来，CatBoost是由Categorical和Boosting组成。此外，CatBoost还解决了梯度偏差（Gradient Bias）以及预测偏移（Prediction shift）的问题，从而减少过拟合的发生，进而提高算法的准确性和泛化能力。

与XGBoost、LightGBM相比，CatBoost的创新点有：

嵌入了自动将类别型特征处理为数值型特征的创新算法。首先对categorical features做一些统计，计算某个类别特征（category）出现的频率，之后加上超参数，生成新的数值型特征（numerical features）。
Catboost还使用了组合类别特征，可以利用到特征之间的联系，这极大的丰富了特征维度。
采用排序提升的方法对抗训练集中的噪声点，从而避免梯度估计的偏差，进而解决预测偏移的问题。
采用了完全对称树作为基模型。

时间序列模型

RNN：https://zhuanlan.zhihu.com/p/45289691

LSTM：https://zhuanlan.zhihu.com/p/83496936

模型对比与性能评估

逻辑回归

优点：

训练速度较快，分类的时候，计算量仅仅只和特征的数目相关；
简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响；
适合二分类问题，不需要缩放输入特征；
内存资源占用小，只需要存储各个维度的特征值；

缺点：

逻辑回归需要预先处理缺失值和异常值；
不能用Logistic回归去解决非线性问题，因为Logistic的决策面是线性的；
对多重共线性数据较为敏感，且很难处理数据不平衡的问题；
准确率并不是很高，因为形式非常简单，很难去拟合数据的真实分布；

决策树模型

优点：

简单直观，生成的决策树可以可视化展示；
数据不需要预处理，不需要归一化，不需要处理缺失数据；
既可以处理离散值，也可以处理连续值；

缺点：

决策树算法非常容易过拟合，导致泛化能力不强（可进行适当的剪枝）；
采用的是贪心算法，容易得到局部最优解；

模型集成方法（ensemble method）

通过组合多个学习器来完成学习任务，通过集成方法，可以将多个弱学习器组合成一个强分类器，因此集成学习的泛化能力一般比单一分类器要好。

集成方法主要包括Bagging和Boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM等。

Baggin和Boosting的区别总结如下：

样本选择上： Bagging方法的训练集是从原始集中有放回的选取，所以从原始集中选出的各轮训练集之间是独立的；而Boosting方法需要每一轮的训练集不变，只是训练集中每个样本在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整；
样例权重上： Bagging方法使用均匀取样，所以每个样本的权重相等；而Boosting方法根据错误率不断调整样本的权值，错误率越大则权重越大；
预测函数上： Bagging方法中所有预测函数的权重相等；而Boosting方法中每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重；
并行计算上： Bagging方法中各个预测函数可以并行生成；而Boosting方法各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

模型评估方法

对于模型来说，其在训练集上面的误差我们称之为训练误差或者经验误差，而在测试集上的误差称之为测试误差。

对于我们来说，我们更关心的是模型对于新样本的学习能力，即我们希望通过对已有样本的学习，尽可能的将所有潜在样本的普遍规律学到手，而如果模型对训练样本学的太好，则有可能把训练样本自身所具有的一些特点当做所有潜在样本的普遍特点，这时候我们就会出现过拟合的问题。

因此我们通常将已有的数据集划分为训练集和测试集两部分，其中训练集用来训练模型，而测试集则是用来评估模型对于新样本的判别能力。

对于数据集的划分，我们通常要保证满足以下两个条件：

训练集和测试集的分布要与样本真实分布一致，即训练集和测试集都要保证是从样本真实分布中独立同分布采样而得；
训练集和测试集要互斥；

对于数据集的划分有三种方法：留出法，交叉验证法和自助法：

留出法
- 留出法是直接将数据集D划分为两个互斥的集合，其中一个集合作为训练集S，另一个作为测试集T。需要注意的是在划分的时候要尽可能保证数据分布的一致性，即避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常我们采用分层采样的方式来对数据进行采样。
- 通常，会将数据集D中大约2/3~4/5的样本作为训练集，其余的作为测试集。
交叉验证法
- k折交叉验证通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。
- 对于交叉验证法，其k值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。
- 当k=1的时候，我们称之为留一法。
自助法
- 我们每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。
- 进行这样采样的原因是因为在D中约有36.8%的数据没有在训练集中出现过。留出法与交叉验证法都是使用分层采样的方式进行数据采样与划分，而自助法则是使用有放回重复采样的方式进行数据采样。

数据集划分总结：

对于数据量充足的时候，通常采用留出法或者k折交叉验证法来进行训练/测试集的划分；
对于数据集小且难以有效划分训练/测试集时使用自助法；
对于数据集小且可有效划分的时候最好使用留一法来进行划分，因为这种方法最为准确；

模型评价标准

对于本次比赛，我们选用auc作为模型评价标准，类似的评价标准还有ks、f1-score等。

在逻辑回归里面，对于正负例的界定，通常会设一个阈值，大于阈值的为正类，小于阈值为负类。如果我们减小这个阀值，更多的样本会被识别为正类，提高正类的识别率，但同时也会使得更多的负类被错误识别为正类。为了直观表示这一现象，引入ROC。

根据分类结果计算得到ROC空间中相应的点，连接这些点就形成ROC curve，横坐标为False Positive Rate(FPR：假正率)，纵坐标为True Positive Rate(TPR：真正率)。一般情况下，这个曲线都应该处于(0,0)和(1,1)连线的上方,如图：

ROC曲线中的四个点：

点(0,1)：即FPR=0, TPR=1，意味着FN＝0且FP＝0，将所有的样本都正确分类；
点(1,0)：即FPR=1，TPR=0，最差分类器，避开了所有正确答案；
点(0,0)：即FPR=TPR=0，FP＝TP＝0，分类器把每个实例都预测为负类；
点(1,1)：分类器把每个实例都预测为正类；

总之：ROC曲线越接近左上角，该分类器的性能越好，其泛化性能就越好。而且一般来说，如果ROC是光滑的，那么基本可以判断没有太大的overfitting。

但是对于两个模型，我们如何判断哪个模型的泛化性能更优呢？这里我们有主要以下两种方法：

如果模型A的ROC曲线完全包住了模型B的ROC曲线，那么我们就认为模型A要优于模型B；
如果两条曲线有交叉的话，我们就通过比较ROC与X，Y轴所围得曲线的面积来判断，面积越大，模型的性能就越优，这个面积我们称之为AUC(area under ROC curve)

代码示例

导入相关关和相关设置

import pandas as pd
import numpy as np
import warnings
import os
import seaborn as sns
import matplotlib.pyplot as plt
"""
sns 相关设置
@return:
"""
# 声明使用 Seaborn 样式
sns.set()
# 有五种seaborn的绘图风格，它们分别是：darkgrid, whitegrid, dark, white, ticks。默认的主题是darkgrid。
sns.set_style("whitegrid")
# 有四个预置的环境，按大小从小到大排列分别为：paper, notebook, talk, poster。其中，notebook是默认的。
sns.set_context('talk')
# 中文字体设置-黑体
plt.rcParams['font.sans-serif'] = ['SimHei']
# 解决保存图像是负号'-'显示为方块的问题
plt.rcParams['axes.unicode_minus'] = False
# 解决Seaborn中文显示问题并调整字体大小
sns.set(font='SimHei')

读取数据

reduce_mem_usage 函数通过调整数据类型，帮助我们减少数据在内存中占用的空间；

def reduce_mem_usage(df):
    start_mem = df.memory_usage().sum() # 计算内存占用量
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        col_type = df[col].dtype
        
        if col_type != object:
            # 处理数值型特征
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                # 处理整型特征
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)  
            else:
                # 处理浮点型特征
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            # 处理类别型特征
            df[col] = df[col].astype('category')

    end_mem = df.memory_usage().sum()  # 计算内存占用量
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

# 读取数据
data_train = pd.read_csv('data/train.csv')
data_test_a = pd.read_csv('data/testA.csv')
data_train = reduce_mem_usage(data_train)
data_test_a = reduce_mem_usage(data_test_a)

简单建模

金融风控的实际项目多涉及到信用评分，因此需要模型特征具有较好的可解释性，所以目前在实际项目中多还是以逻辑回归作为基础模型。但是在比赛中以得分高低为准，不需要严谨的可解释性，所以大多基于集成算法进行建模。
因为逻辑回归的算法特性，需要提前对异常值、缺失值数据进行处理。
基于树模型的算法特性，异常值、缺失值处理可以跳过，但是对于业务较为了解的同学也可以自己对缺失异常值进行处理，效果可能会更优于模型处理的结果。

建模之前的预操作；

from sklearn.model_selection import KFold

# 分离数据集，方便进行交叉验证
y_train = data_train['isDefault']
X_train = data_train.drop(['id', 'issueDate', 'isDefault'], axis=1)
X_test = data_test_a.drop(['id', 'issueDate'], axis=1)

# 5折交叉验证
folds = 5
seed = 2020
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

使用Lightgbm进行建模；

"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""
from sklearn.model_selection import train_test_split
import lightgbm as lgb

# 数据集划分
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
valid_matrix = lgb.Dataset(X_val, label=y_val)

# 参数设置
params = {
            'boosting_type': 'gbdt',
            'objective': 'binary',
            'learning_rate': 0.1,
            'metric': 'auc',
            'min_child_weight': 1e-3,
            'num_leaves': 31,
            'max_depth': -1,
            'reg_lambda': 0,
            'reg_alpha': 0,
            'feature_fraction': 1,
            'bagging_fraction': 1,
            'bagging_freq': 0,
            'seed': 2020,
            'nthread': 8,
            'silent': True,
            'verbose': -1,
}

"""使用训练集数据进行模型训练"""
model = lgb.train(params, train_set=train_matrix, valid_sets=valid_matrix, num_boost_round=20000, verbose_eval=1000, early_stopping_rounds=200)

# Training until validation scores don't improve for 200 rounds
# Early stopping, best iteration is:
# [92]	valid_0's auc: 0.719129

对验证集进行预测；

from sklearn import metrics
from sklearn.metrics import roc_auc_score

"""预测并计算roc的相关指标"""
val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
roc_auc = metrics.auc(fpr, tpr)
print('未调参前lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))

"""画出roc曲线图"""
plt.figure(figsize=(8, 8))
plt.title('Validation ROC')
plt.plot(fpr, tpr, 'b', label = 'Val AUC = %0.4f' % roc_auc)
plt.ylim(0,1)
plt.xlim(0,1)
plt.legend(loc='best')
plt.title('ROC')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')

# 画出对角线
plt.plot([0,1],[0,1],'r--')
plt.show()

更进一步的，使用5折交叉验证进行模型性能评估；

import lightgbm as lgb

"""使用lightgbm 5折交叉验证进行建模预测"""
cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i+1)))
    # 数据集划分
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[valid_index], y_train[valid_index]
    
    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)

    # 参数设置
    params = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'learning_rate': 0.1,
                'metric': 'auc',
                'min_child_weight': 1e-3,
                'num_leaves': 31,
                'max_depth': -1,
                'reg_lambda': 0,
                'reg_alpha': 0,
                'feature_fraction': 1,
                'bagging_fraction': 1,
                'bagging_freq': 0,
                'seed': 2020,
                'nthread': 8,
                'silent': True,
                'verbose': -1,
    }
    
    """使用训练集数据进行模型训练"""
    model = lgb.train(params, train_set=train_matrix, num_boost_round=20000, valid_sets=valid_matrix, verbose_eval=1000, early_stopping_rounds=200)
    val_pred = model.predict(X_val, num_iteration=model.best_iteration)
    
    cv_scores.append(roc_auc_score(y_val, val_pred))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

# lgb_scotrainre_list:[0.7189831988378461, 0.7153915866572624, 0.7194764444838756, 0.7186469467349867, 0.7194349846324942]
# lgb_score_mean:0.718386632269293
# lgb_score_std:0.0015284427925435235

模型调参

贪心调参

先使用当前对模型影响最大的参数进行调优，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕。

这个方法的缺点就是可能会调到局部最优而不是全局最优，但是只需要一步一步的进行参数最优化调试即可，容易理解。

需要注意的是在树模型中参数调整的顺序，也就是各个参数对模型的影响程度，这里列举一下日常调参过程中常用的参数和调参顺序：

max_depth、num_leaves
min_data_in_leaf、min_child_weight
bagging_fraction、 feature_fraction、bagging_freq
reg_lambda、reg_alpha
min_split_gain

from sklearn.model_selection import cross_val_score

# 调objective
best_obj = dict()
for obj in objective:
    model = LGBMRegressor(objective=obj)
    """预测并计算roc的相关指标"""
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_obj[obj] = score
    
# num_leaves
best_leaves = dict()
for leaves in num_leaves:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
    """预测并计算roc的相关指标"""
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_leaves[leaves] = score
    
# max_depth
best_depth = dict()
for depth in max_depth:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0],
                          num_leaves=min(best_leaves.items(), key=lambda x:x[1])[0],
                          max_depth=depth)
    """预测并计算roc的相关指标"""
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_depth[depth] = score

可依次将模型的参数通过上面的方式进行调整优化，并且通过可视化观察在每一个最优参数下模型的得分情况；

网格搜索

sklearn 提供GridSearchCV用于进行网格搜索，只需要把模型的参数输进去，就能给出最优化的结果和参数。相比起贪心调参，网格搜索的结果会更优，但是网格搜索只适合于小数据集，一旦数据的量级上去了，很难得出结果。

同样以Lightgbm算法为例，进行网格搜索调参；

"""通过网格搜索确定最优参数"""
from sklearn.model_selection import GridSearchCV, StratifiedKFold

def get_best_cv_params(learning_rate=0.1, n_estimators=581, num_leaves=31, max_depth=-1, bagging_fraction=1.0, 
                       feature_fraction=1.0, bagging_freq=0, min_data_in_leaf=20, min_child_weight=0.001, 
                       min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=None):
    # 设置5折交叉验证
    cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True)
    
    model_lgb = lgb.LGBMClassifier(learning_rate=learning_rate,
                                   n_estimators=n_estimators,
                                   num_leaves=num_leaves,
                                   max_depth=max_depth,
                                   bagging_fraction=bagging_fraction,
                                   feature_fraction=feature_fraction,
                                   bagging_freq=bagging_freq,
                                   min_data_in_leaf=min_data_in_leaf,
                                   min_child_weight=min_child_weight,
                                   min_split_gain=min_split_gain,
                                   reg_lambda=reg_lambda,
                                   reg_alpha=reg_alpha,
                                   n_jobs= 8
                                  )
    grid_search = GridSearchCV(estimator=model_lgb, 
                               cv=cv_fold,
                               param_grid=param_grid,
                               scoring='roc_auc'
                              )
    grid_search.fit(X_train, y_train)

    print('模型当前最优参数为:{}'.format(grid_search.best_params_))
    print('模型当前最优得分为:{}'.format(grid_search.best_score_))

以下代码耗时较长，请谨慎运行，且每一步的最优参数需要在下一步进行手动更新，请注意；
需要注意一下的是，除了获取上面的获取num_boost_round时候用的是原生的lightgbm（因为要用自带的cv）下面配合GridSearchCV时必须使用sklearn接口的lightgbm；

"""设置n_estimators 为581，调整num_leaves和max_depth，这里选择先粗调再细调"""
lgb_params = {'num_leaves': range(10, 80, 5), 'max_depth': range(3,10,2)}
get_best_cv_params(learning_rate=0.1, n_estimators=581, num_leaves=None, max_depth=None, min_data_in_leaf=20, 
                   min_child_weight=0.001,bagging_fraction=1.0, feature_fraction=1.0, bagging_freq=0, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

"""num_leaves为30，max_depth为7，进一步细调num_leaves和max_depth"""
lgb_params = {'num_leaves': range(25, 35, 1), 'max_depth': range(5,9,1)}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=None, max_depth=None, min_data_in_leaf=20, 
                   min_child_weight=0.001,bagging_fraction=1.0, feature_fraction=1.0, bagging_freq=0, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

"""
确定min_data_in_leaf为45，min_child_weight为0.001 ，下面进行bagging_fraction、feature_fraction和bagging_freq的调参
"""
lgb_params = {'bagging_fraction': [i/10 for i in range(5,10,1)], 
              'feature_fraction': [i/10 for i in range(5,10,1)],
              'bagging_freq': range(0,81,10)
             }
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=None, feature_fraction=None, bagging_freq=None, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

"""
确定bagging_fraction为0.4、feature_fraction为0.6、bagging_freq为 ，下面进行reg_lambda、reg_alpha的调参
"""
lgb_params = {'reg_lambda': [0,0.001,0.01,0.03,0.08,0.3,0.5], 'reg_alpha': [0,0.001,0.01,0.03,0.08,0.3,0.5]}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=0.9, feature_fraction=0.9, bagging_freq=40, 
                   min_split_gain=0, reg_lambda=None, reg_alpha=None, param_grid=lgb_params)

"""
确定reg_lambda、reg_alpha都为0，下面进行min_split_gain的调参
"""
lgb_params = {'min_split_gain': [i/10 for i in range(0,11,1)]}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=0.9, feature_fraction=0.9, bagging_freq=40, 
                   min_split_gain=None, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

参数确定好了以后，我们设置一个比较小的learning_rate 0.01，来确定最终的num_boost_round；

# 设置5折交叉验证
# cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True, )
final_params = {
                'boosting_type': 'gbdt',
                'learning_rate': 0.01,
                'num_leaves': 29,
                'max_depth': 7,
                'min_data_in_leaf':45,
                'min_child_weight':0.001,
                'bagging_fraction': 0.9,
                'feature_fraction': 0.9,
                'bagging_freq': 40,
                'min_split_gain': 0,
                'reg_lambda':0,
                'reg_alpha':0,
                'nthread': 6
               }

cv_result = lgb.cv(train_set=lgb_train,
                   early_stopping_rounds=20,
                   num_boost_round=5000,
                   nfold=5,
                   stratified=True,
                   shuffle=True,
                   params=final_params,
                   metrics='auc',
                   seed=0,
                  )

print('迭代次数{}'.format(len(cv_result['auc-mean'])))
print('交叉验证的AUC为{}'.format(max(cv_result['auc-mean'])))

# 迭代次数1095
# 交叉验证的AUC为0.7182804513645005

在实际调整过程中，可先设置一个较大的学习率（上面的例子中0.1），通过Lgb原生的cv函数进行树个数的确定，之后再通过上面的实例代码进行参数的调整优化。
最后针对最优的参数设置一个较小的学习率（例如0.01），同样通过cv函数确定树的个数，确定最终的参数。
需要注意的是，针对大数据集，上面每一层参数的调整都需要耗费较长时间。

贝叶斯调参

在使用之前需要先安装包bayesian-optimization，运行如下命令即可：

pip install bayesian-optimization

贝叶斯调参的主要思想是：给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布）。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。

贝叶斯调参的步骤如下：

定义优化函数(rf_cv）；
建立模型；
定义待优化的参数；
得到优化结果，并返回要优化的分数指标；

from sklearn.model_selection import cross_val_score
from bayes_opt import BayesianOptimization

"""定义优化函数"""
def rf_cv_lgb(num_leaves, max_depth, bagging_fraction, feature_fraction, bagging_freq, min_data_in_leaf, 
              min_child_weight, min_split_gain, reg_lambda, reg_alpha):
    # 建立模型
    model_lgb = lgb.LGBMClassifier(boosting_type='gbdt', bjective='binary', metric='auc',
                                   learning_rate=0.1, n_estimators=5000,
                                   num_leaves=int(num_leaves), max_depth=int(max_depth), 
                                   bagging_fraction=round(bagging_fraction, 2), feature_fraction=round(feature_fraction, 2),
                                   bagging_freq=int(bagging_freq), min_data_in_leaf=int(min_data_in_leaf),
                                   min_child_weight=min_child_weight, min_split_gain=min_split_gain,
                                   reg_lambda=reg_lambda, reg_alpha=reg_alpha,
                                   n_jobs= 8
                                  )
    
    val = cross_val_score(model_lgb, X_train_split, y_train_split, cv=5, scoring='roc_auc').mean()
    
    return val

"""定义优化参数"""
bayes_lgb = BayesianOptimization(
    rf_cv_lgb, 
    {
        'num_leaves':(10, 200),
        'max_depth':(3, 20),
        'bagging_fraction':(0.5, 1.0),
        'feature_fraction':(0.5, 1.0),
        'bagging_freq':(0, 100),
        'min_data_in_leaf':(10,100),
        'min_child_weight':(0, 10),
        'min_split_gain':(0.0, 1.0),
        'reg_alpha':(0.0, 10),
        'reg_lambda':(0.0, 10),
    }
)

"""开始优化"""
bayes_lgb.maximize(n_iter=10)

显示优化结果；

bayes_lgb.max

参数优化完成后，我们可以根据优化后的参数建立新的模型，降低学习率并寻找最优模型迭代次数；

"""调整一个较小的学习率，并通过cv函数确定当前最优的迭代次数"""
base_params_lgb = {
                    'boosting_type': 'gbdt',
                    'objective': 'binary',
                    'metric': 'auc',
                    'learning_rate': 0.01,
                    'num_leaves': 14,
                    'max_depth': 19,
                    'min_data_in_leaf': 37,
                    'min_child_weight':1.6,
                    'bagging_fraction': 0.98,
                    'feature_fraction': 0.69,
                    'bagging_freq': 96,
                    'reg_lambda': 9,
                    'reg_alpha': 7,
                    'min_split_gain': 0.4,
                    'nthread': 8,
                    'seed': 2020,
                    'silent': True,
                    'verbose': -1,
}

cv_result_lgb = lgb.cv(
    train_set=train_matrix,
    early_stopping_rounds=1000, 
    num_boost_round=20000,
    nfold=5,
    stratified=True,
    shuffle=True,
    params=base_params_lgb,
    metrics='auc',
    seed=0
)

print('迭代次数{}'.format(len(cv_result_lgb['auc-mean'])))
print('最终模型的AUC为{}'.format(max(cv_result_lgb['auc-mean'])))

# 迭代次数3229
# 最终模型的AUC为0.7218316823491577

模型参数已经确定，建立最终模型并对验证集进行验证；

import lightgbm as lgb

"""使用lightgbm 5折交叉验证进行建模预测"""
cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i+1)))
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[valid_index], y_train[valid_index]
    
    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)

    params = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'metric': 'auc',
                'learning_rate': 0.01,
                'num_leaves': 14,
                'max_depth': 19,
                'min_data_in_leaf': 37,
                'min_child_weight':1.6,
                'bagging_fraction': 0.98,
                'feature_fraction': 0.69,
                'bagging_freq': 96,
                'reg_lambda': 9,
                'reg_alpha': 7,
                'min_split_gain': 0.4,
                'nthread': 8,
                'seed': 2020,
                'silent': True,
    }
    
    model = lgb.train(params, train_set=train_matrix, num_boost_round=14269, valid_sets=valid_matrix, verbose_eval=1000, early_stopping_rounds=200)
    val_pred = model.predict(X_val, num_iteration=model.best_iteration)
    
    cv_scores.append(roc_auc_score(y_val, val_pred))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

# lgb_scotrainre_list:[0.7243989768290735, 0.720405047892458, 0.724143719768038, 0.7236917059085686, 0.7238346328989569]
# lgb_score_mean:0.7232948166594191
# lgb_score_std:0.001465571038410448

通过5折交叉验证可以发现，模型迭代次数在13000次的时候会停之，那么我们在建立新模型时直接设置最大迭代次数，并使用验证集进行模型预测

""""""
base_params_lgb = {
                    'boosting_type': 'gbdt',
                    'objective': 'binary',
                    'metric': 'auc',
                    'learning_rate': 0.01,
                    'num_leaves': 14,
                    'max_depth': 19,
                    'min_data_in_leaf': 37,
                    'min_child_weight':1.6,
                    'bagging_fraction': 0.98,
                    'feature_fraction': 0.69,
                    'bagging_freq': 96,
                    'reg_lambda': 9,
                    'reg_alpha': 7,
                    'min_split_gain': 0.4,
                    'nthread': 8,
                    'seed': 2020,
                    'silent': True,
}

"""使用训练集数据进行模型训练"""
final_model_lgb = lgb.train(base_params_lgb, train_set=train_matrix, valid_sets=valid_matrix, num_boost_round=13000, verbose_eval=1000, early_stopping_rounds=200)

"""预测并计算roc的相关指标"""
val_pre_lgb = final_model_lgb.predict(X_val)
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
roc_auc = metrics.auc(fpr, tpr)
print('调参后lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))

# 调参后lightgbm单模型在验证集上的AUC：0.7238346328989569

"""画出roc曲线图"""
plt.figure(figsize=(8, 8))
plt.title('Validation ROC')
plt.plot(fpr, tpr, 'b', label = 'Val AUC = %0.4f' % roc_auc)
plt.ylim(0,1)
plt.xlim(0,1)
plt.legend(loc='best')
plt.title('ROC')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')

# 画出对角线
plt.plot([0,1],[0,1],'r--')
plt.show()

保存模型到本地；

# 保存模型
import pickle
pickle.dump(final_model_lgb, open('dataset/model_lgb_best.pkl', 'wb'))

模型调参小总结：

集成模型内置的cv函数可以较快的进行单一参数的调节，一般可以用来优先确定树模型的迭代次数；
数据量较大的时候（例如本次项目的数据），网格搜索调参会特别特别慢，不建议尝试；
集成模型中原生库和sklearn下的库部分参数不一致，需要注意，具体可以参考xgb和lgb的官方API；
- xgb原生库API，sklearn库下xgbAPI
- lgb原生库API， sklearn库下lgbAPI