集成学习算法汇总----Boosting和Bagging（推荐AAA）

时间 2019-11-24

标签集成学习算法汇总 boosting bagging 推荐 aaa 栏目 C&C++ 繁體版

原文原文链接

python机器学习-乳腺癌细胞挖掘（博主亲自录制视频）

https://study.163.com/course/introduction.htm?courseId=1005269003&utm_campaign=commission&utm_source=cp-400000000398149&utm_medium=share

adaboost(adaptive boost)python

bootsting is a fairly simple variation on bagging that strives to improve the learners by
focusing area where the system is not performing wellredis

bootsting和bagging有一些小区别，算法

重点关注系统表现不佳的地区，从而获得改进bootstrap

此算法不太容易过分拟合
建议先去噪声，噪音影响权重安全

集成机器学习算法代价-计算量太大微信

a 越小，分类越多，偏差越小，越平滑网络

ensemble methods and machine learning are a kind of meta algorithm that make use of other machine learning algorithms as a component to learn a collection of predictors ensemble methods take the attitude that more predictors can bebetter than any single oneantd

集合方法和机器学习是一种元算法，利用其余机器学习算法做为组件来学习预测数据，多个算法组合能够比任何单一的算法更优越。app

http://lib.csdn.net/article/machinelearning/35135框架

集成学习在机器学习算法中具备较高的准去率，不足之处就是模型的训练过程可能比较复杂，效率不是很高。目前接触较多的集成学习主要有2种：基于Boosting的和基于Bagging，前者的表明算法有Adaboost、GBDT、XGBOOST、后者的表明算法主要是随机森林。

一、集成学习概述

1.1 集成学习概述

1.2 集成学习的主要思想
集成学习的主要思想是利用必定的手段学习出多个分类器，并且这多个分类器要求是弱分类器，而后将多个分类器进行组合公共预测。核心思想就是如何训练处多个弱分类器以及如何将这些弱分类器进行组合。

1.三、集成学习中弱分类器选择
通常采用弱分类器的缘由在于将偏差进行均衡，由于一旦某个分类器太强了就会形成后面的结果受其影响太大，严重的会致使后面的分类器没法进行分类。经常使用的弱分类器能够采用偏差率小于0.5的，好比说逻辑回归、SVM、神经网络。

1.四、多个分类器的生成
能够采用随机选取数据进行分类器的训练，也能够采用不断的调整错误分类的训练数据的权重生成新的分类器。

1.五、多个弱分类区如何组合
基本分类器之间的整合方式，通常有简单多数投票、权重投票，贝叶斯投票，基于D-S证据理论的整合，基于不一样的特征子集的整合。

二、Boosting算法

2.1 基本概念

Boosting方法是一种用来提升弱分类算法准确度的方法,这种方法经过构造一个预测函数系列,而后以必定的方式将他们组合成一个预测函数。他是一种框架算法,主要是经过对样本集的操做得到样本子集,而后用弱分类算法在样本子集上训练生成一系列的基分类器。他能够用来提升其余弱分类算法的识别率,也就是将其余的弱分类算法做为基分类算法放于Boosting 框架中,经过Boosting框架对训练样本集的操做,获得不一样的训练样本子集,用该样本子集去训练生成基分类器;每获得一个样本集就用该基分类算法在该样本集上产生一个基分类器,这样在给定训练轮数 n 后,就可产生 n 个基分类器,而后Boosting框架算法将这 n个基分类器进行加权融合,产生一个最后的结果分类器,在这 n个基分类器中,每一个单个的分类器的识别率不必定很高,但他们联合后的结果有很高的识别率,这样便提升了该弱分类算法的识别率。在产生单个的基分类器时可用相同的分类算法,也可用不一样的分类算法,这些算法通常是不稳定的弱分类算法,如神经网络(BP) ,决策树(C4.5)等。

2.二、Adaboost

Adaboost是boosting中较为表明的算法，基本思想是经过训练数据的分布构造一个分类器，而后经过偏差率求出这个若弱分类器的权重，经过更新训练数据的分布，迭代进行，直到达到迭代次数或者损失函数小于某一阈值。

Adaboost的算法流程：
假设训练数据集为T={(X1,Y1),(X2,Y2),(X3,Y3),(X4,Y4),(X5,Y5)} 其中Yi={-1,1}

一、初始化训练数据的分布
训练数据的权重分布为D={W11,W12,W13,W14,W15},其中W1i=1/N。即平均分配。

二、选择基本分类器
这里选择最简单的线性分类器y=aX+b ，分类器选定以后，最小化分类偏差能够求得参数。

三、计算分类器的系数和更新数据权重
偏差率也能够求出来为e1.同时能够求出这个分类器的系数。基本的Adaboost给出的系数计算公式为
而后更新训练数据的权重分布，
（图片来自李航的统计学习方法）

四、分类器的组合

固然这种组合方式基于分类器的系数的，而分类器的系数又是根据偏差率求出来的，因此Adaboots最后影响的就是如何使用偏差率，以及训练数据更新权重的的计算系数。

五、Adaboost的一些问题

Adaboost中涉及到一些能够进行调整的参数和计算公式的选择主要有如下几点：

**弱分类器如何选择
**如何更好的实验偏差率计算分类器的系数
**如何更好的计算训练数据的权重的分布
**弱分类器如何进行组合
**迭代次数
**损失函数的阈值选取多少

三、Bagging算法

bagging方法bootstrap aggregating的缩写，采用的是随机有放回的选择训练数据而后构造分类器，最后组合。这里以随机森林为例进行讲解。
随机森林算法概述

随机森林算法是上世纪八十年代Breiman等人提出来的，其基本思想就是构造不少棵决策树，造成一个森林，而后用这些决策树共同决策输出类别是什么。随机森林算法及在构建单一决策树的基础上的，同时是单一决策树算法的延伸和改进。在整个随机森林算法的过程当中，有两个随机过程，第一个就是输入数据是随机的从总体的训练数据中选取一部分做为一棵决策树的构建，并且是有放回的选取；第二个就是每棵决策树的构建所需的特征是从总体的特征集随机的选取的，这两个随机过程使得随机森林很大程度上避免了过拟合现象的出现。

随机森林算法具体的过程：

一、从训练数据中选取n个数据做为训练数据输入，通常状况下n是远小于总体的训练数据N的，这样就会形成有一部分数据是没法被去到的，这部分数据称为袋外数据，可使用袋外数据作偏差估计。

二、选取了输入的训练数据的以后，须要构建决策树，具体方法是每个分裂结点从总体的特征集M中选取m个特征构建，通常状况下m远小于M。

三、在构造每棵决策树的过程当中，按照选取最小的基尼指数进行分裂节点的选取进行决策树的构建。决策树的其余结点都采起相同的分裂规则进行构建，直到该节点的全部训练样例都属于同一类或者达到树的最大深度。

四、重复第2步和第3步屡次，每一次输入数据对应一颗决策树，这样就获得了随机森林，能够用来对预测数据进行决策。

五、输入的训练数据选择好了，多棵决策树也构建好了，对待预测数据进行预测，好比说输入一个待预测数据，而后多棵决策树同时进行决策，最后采用多数投票的方式进行类别的决策。

随机森林算法图示

随机森林算法的注意点：

一、在构建决策树的过程当中是不须要剪枝的。
二、整个森林的树的数量和每棵树的特征须要人为进行设定。
三、构建决策树的时候分裂节点的选择是依据最小基尼系数的。

随机森林有不少的优势：

a. 在数据集上表现良好，两个随机性的引入，使得随机森林不容易陷入过拟合。

b. 在当前的不少数据集上，相对其余算法有着很大的优点，两个随机性的引入，使得随机森林具备很好的抗噪声能力。

c. 它可以处理很高维度（feature不少）的数据，而且不用作特征选择，对数据集的适应能力强：既能处理离散型数据，也能处理连续型数据，数据集无需规范化。

d. 在建立随机森林的时候，对generlization error使用的是无偏估计。

e. 训练速度快，能够获得变量重要性排序。

f. 在训练过程当中，可以检测到feature间的互相影响。

g 容易作成并行化方法。

h. 实现比较简单。

1、主要目的

虽然大多数Kaggle竞赛获胜者使用各类模型的叠加/集合，可是一个特定的模式是大部分集合的部分是梯度提高（GBM）算法的一些变体。以最新的Kaggle比赛获胜者为例：Michael Jahrer的解决方案是在安全驾驶的预测中的表示学习。他的解决方案是6个模型的混合。1 个LightGBM（GBM的变体）和5个神经网络。虽然他的成功归因于他为结构化数据发明的新的半监督学习，但梯度提高模型也发挥了做用。

尽管GBM被普遍使用，许多从业人员仍然将其视为复杂的黑盒算法，只是使用预建的库运行模型。这篇文章的目的是为了简化所谓复杂的算法，并帮助读者直观地理解算法。我将解释基本版本的梯度提高算法，并将在最后分享其不一样的变体的连接。我已经从fast.ai库（fastai/courses/ml1/lesson3-rf_foundations.ipynb）取得了基本的DecisionTree代码，最重要的是，我创建了本身的简单版本的基本梯度提高模型。

关于Ensemble, Bagging 和 Boosting的简要描述

当咱们试图用任何机器学习技术来预测目标变量时，实际值和预测值的主要差别是噪声，方差和误差。集成有助于减小这些因素。

一个集合只是一个聚集在一块儿（例如全部预测的平均值）来做出最终预测的预测器集合。咱们使用集成的缘由是许多不一样的预测变量试图预测相同的目标变量将比任何单一的预测器完成的更好。集成技术进一步分为Bagging和Boosting。

Bagging是一个简单的集成技术，咱们创建许多独立的预测变量/模型/学习者，并使用一些模型平均技术将它们结合起来。（例如加权平均数，多数票或正态平均数）。

咱们一般对每一个模型采用随机的子样本/bootstrap数据，所以全部模型彼此之间几乎没有差异。每一个观察结果在全部模型中出现的几率相同。由于这种技术须要许多不相关的学习者作出最终的模型，因此经过减小方差来减小错误。Bagging集成的例子是随机森林模型。

Boosting是一种集成技术，其中预测变量不是独立的，而是按顺序进行的。

这种技术使用了后面的预测变量从以前的预测变量的错误中学习的逻辑。所以，观测值在后续模型中出现的几率是不相同的，而偏差最大的出现最频繁。预测变量能够从一系列模型中选择，如决策树，回归量，分类器等等。由于新的预测变量是从之前的预测变量所犯的错误中学习的，因此须要更少的时间/次数来接近实际的预测。可是咱们必须慎重选择停机判据，不然可能致使训练数据过分拟合。梯度提高是Boosting算法的一个例子。

图1.集成

图2. Bagging (独立模式) 和 Boosting (顺序模式).

参考：https：//quantdare.com/what-is-the-ding-between-bagging-and-boosting /

2、梯度提高算法

在维基百科的定义中，梯度提高是一种用于回归和分类问题的机器学习技术，它以弱预测模型（一般是决策树）的集合的形式产生预测模型。

任何监督学习算法的目标是定义一个损失函数，并将其最小化。让咱们看看梯度提高算法的数学运算。假设咱们将均方根偏差（MSE）定义为：

咱们但愿咱们的预测，使咱们的损失函数（MSE）最小。经过使用梯度降低和基于学习速率更新咱们的预测，咱们能够找到MSE最小的值。

因此，咱们基本上是更新预测，使咱们的残差总和接近0（或最小），预测值足够接近实际值。

3、梯度提高背后的直觉

梯度提高背后的逻辑很简单，（能够直观地理解，不使用数学符号）。我指望任何阅读这篇文章的人均可以熟悉简单的线性回归模型。

线性回归的一个基本假设是其残差之和为0，即残差应该在0左右随机分布。

图3.抽样随机正态分布残差均值在0附近

如今把这些残差看做咱们的预测模型所犯的错误。虽然基于树的模型（把决策树看成咱们梯度提高的基本模型）并非基于这样的假设，可是若是咱们从逻辑上（而不是统计上）考虑这个假设，那么咱们可能证实，若是咱们可以看到一些残差在0左右的模式，咱们能够利用这种模式来拟合模型。

所以，梯度提高算法的直觉就是反复利用残差模式，增强预测能力较弱的模型，使其更好。一旦咱们达到残差没有任何模式能够建模的阶段，咱们能够中止建模残差（不然可能致使过分拟合）。在算法上，咱们正在最小化咱们的损失函数，使得测试损失达到最小值。

综上所述，

咱们首先用简单的模型对数据进行建模，并分析错误的数据。
这些错误经过一个简单的模型来表示数据点是很难的。
那么对于之后的模型，咱们特别关注那些难以处理的数据，以使它们正确。
最后，咱们经过给每一个预测变量赋予一些权重来组合全部的预测变量。

关于同一逻辑的更为技术性的引用写在Probably Approximately Correct: Nature’s Algorithms for Learning and Prospering in a Complex World，“这个想法是屡次使用弱的学习方法来得到连续的假设，每个调整的例子是以往发现困难和错误分类的。...可是，请注意，能作到这一点并不明显”。

4、拟合梯度提高模型的步骤

让咱们思考下面的散点图中显示的模拟数据，其中1个输入（x）和1个输出（y）变量。

图4.模拟数据（x：输入，y：输出）

上面显示的图的数据是使用下面的python代码生成的：

一、对数据拟合一个简单的线性回归或决策树（我在个人代码中选择了决策树）[将x做为输入，将y做为输出]

二、计算偏差残差。实际目标值减去预测目标值[e1 = y_predicted1 - y]

三、将偏差残差的新模型做为具备相同输入变量的目标变量[称为e1_predicted]

四、将预测的残差添加到先前的预测中[y_predicted2 = y_predicted1 + e1_predicted]

五、在剩余的残差上拟合另外一个模型。即[e2 = y-y_predicted2]并重复步骤2到5，直到它开始过拟合或残差总和变成恒定。过分拟合能够经过持续检查验证数据的准确性来控制。

为了帮助理解基本概念，下面是从零开始完整实现简单梯度提高模型的连接。 [连接：从头开始梯度提高]

共享代码是一种非优化的梯度提高的普通实现。库中的大多数梯度提高模型都通过了很好的优化，而且有不少超参数。

6、工做梯度提高树的可视化

蓝点（左）是输入（x）与输出（y）的关系•红线（左）显示由决策树预测的值•绿点（右）显示第i次迭代的残差与输入（x）•迭表明示拟合梯度提高树的顺序。

图5.梯度提高预测的可视化（前4次迭代）

图6.梯度提高预测的可视化（第18次至第20次迭代）

咱们观察到，在第20次迭代以后，残差在0附近是随机分布的（我并非说随机的正态分布），咱们的预测很是接近真实值。（迭代在sklearn实现中被称为n_estimators）。这将是一个很好的点来中止或开始过分拟合模型。

让咱们看看咱们的模型在第五十次迭代中的样子。

咱们能够看到，即便在第50次迭代以后，残差对x的曲线看起来也与咱们在第20次迭代中看到的类似。可是，模型变得愈来愈复杂，预测过分的训练数据，并试图学习每一个训练数据。因此，最好是中止在第20次迭代。

用于绘制全部上述数据的Python代码片断：

# plotting after prediction xa = np.array(x.x) # column name of x is x order = np.argsort(xa) xs = np.array(xa)[order] ys = np.array(predf)[order] #epreds = np.array(epred[:,None])[order] f, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize = (13,2.5)) ax1.plot(x,y, 'o') ax1.plot(xs, ys, 'r') ax1.set_title(f'Prediction (Iteration {i+1})') ax1.set_xlabel('x') ax1.set_ylabel('y / y_pred') ax2.plot(x, ei, 'go') ax2.set_title(f'Residuals vs. x (Iteration {i+1})') ax2.set_xlabel('x') ax2.set_ylabel('Residuals')

https://quantdare.com/what-is-the-difference-between-bagging-and-boosting/

bagging 和boosting都是集成机器学习算法，他们都把弱学习机器组合在一块儿，变成强学习机器。

Bagging and Boosting are both ensemble methods in Machine Learning, but what’s the key behind them?

Bagging and Boosting are similar in that they are both ensemble techniques, where a set of weak learners are combined to create a strong learner that obtains better performance than a single one. So, let’s start from the beginning:

What is an ensemble method?

成百上千学习机器可组合起来共同解决问题

Ensemble is a Machine Learning concept in which the idea is to train multiple models using the same learning algorithm. The ensembles take part in a bigger group of methods, called multiclassifiers, where a set of hundreds or thousands of learners with a common objective are fused together to solve the problem.

The second group of multiclassifiers contain the hybrid methods. They use a set of learners too, but they can be trained using different learning techniques. Stacking is the most well-known. If you want to learn more about Stacking, you can read my previous post, “Dream team combining classifiers“.

学习中主要错误包括噪音，误差和方差。集成机器学习有助于下降噪音，误差和方差。下降方差能够提升模型稳定性。

The main causes of error in learning are due to noise, bias and variance. Ensemble helps to minimize these factors. These methods are designed to improve the stability and the accuracy of Machine Learning algorithms. Combinations of multiple classifiers decrease variance, especially in the case of unstable classifiers, and may produce a more reliable classification than a single classifier.

使用 Bagging 或Boosting，你必须选择一个基础算法。若是咱们选择分类树，Bagging 或Boosting将包括众多树。

To use Bagging or Boosting you must select a base learner algorithm. For example, if we choose a classification tree, Bagging and Boosting would consist of a pool of trees as big as we want.

How do Bagging and Boosting get N learners?

重复抽样法把训练数据分为若干份。Bagging任何一个元素有相同几率出如今新的训练数据集，可是boosting用了加权，某些元素出现几率不一样。

Bagging and Boosting get N learners by generating additional data in the training stage. N new training data sets are produced by random sampling with replacement from the original set. By sampling with replacement some observations may be repeated in each new training data set.

In the case of Bagging, any element has the same probability to appear in a new data set. However, for Boosting the observations are weighted and therefore some of them will take part in the new sets more often:

These multiple sets are used to train the same learner algorithm and therefore different classifiers are produced.

Why are the data elements weighted?

bagging用并行方法训练数据，boosting用线性方法训练数据

At this point, we begin to deal with the main difference between the two methods. While the training stage is parallel for Bagging (i.e., each model is built independently), Boosting builds the new learner in a sequential way:

boosting算法中，每一个分类器用于训练数据时参考了以前分类器的成功失败。每次训练后，权重会程序调整。分错的数据会增长错误分类数据的权重。下一个分类器会关注上个分类器错误的数据（权重大）

In Boosting algorithms each classifier is trained on data, taking into account the previous classifiers’ success. After each training step, the weights are redistributed. Misclassified data increases its weights to emphasise the most difficult cases. In this way, subsequent learners will focus on them during their training.

How does the classification stage work?

分类环节中，bagging采用投票机制，少数服从多数。boosting采用加权平均法来预测数据。

To predict the class of new data we only need to apply the N learners to the new observations. In Bagging the result is obtained by averaging the responses of the N learners (or majority vote). However, Boosting assigns a second set of weights, this time for the N classifiers, in order to take a weighted average of their estimates.

在Boosting训练阶段，算法为每一个结果模型分配权重。训练数据的分类结果良好的学习者将被赋予高权重，差的分类器被赋予低权重。所以，在评估新学习者时，boosting要跟踪以前学习机器的错误

In the Boosting training stage, the algorithm allocates weights to each resulting model. A learner with good a classification result on the training data will be assigned a higher weight than a poor one. So when evaluating a new learner, Boosting needs to keep track of learners’ errors, too. Let’s see the differences in the procedures:

一些新的boosting算法包括额外条件保留或丢弃学习机器。例如，在AdaBoost中，最着名的是，维护模型须要小于50％的偏差; 不然，重复迭代直至得到比随机猜想更好的学习机器。boosting算法中，常见的有 AdaBoost, LPBoost, XGBoost, GradientBoost, BrownBoost

Some of the Boosting techniques include an extra-condition to keep or discard a single learner. For example, in AdaBoost, the most renowned, an error less than 50% is required to maintain the model; otherwise, the iteration is repeated until achieving a learner better than a random guess.

The previous image shows the general process of a Boosting method, but several alternatives exist with different ways to determine the weights to use in the next training step and in the classification stage. Click here if you like to go into detail: AdaBoost, LPBoost, XGBoost, GradientBoost, BrownBoost.

Which is the best, Bagging or Boosting?

bagging和boosting哪一个分类器最好?没有最好分类器，要根据数据维度，数据分布，环境，缺失值，数据量，目标等来选择模型。bagging和boosting下降单个模型方差，他们均可以获得稳定性最好模型。若是一个模型的表现力不好，bagging很难减小误差，boosting能够减小误差，让模型得到更高准确性。

若是模型的主要问题是过分拟合，bagging是最好选择。boosting不能解决过分拟合问题

There’s not an outright winner; it depends on the data, the simulation and the circumstances.
Bagging and Boosting decrease the variance of your single estimate as they combine several estimates from different models. So the result may be a model with higher stability.

If the problem is that the single model gets a very low performance, Bagging will rarely get a better bias. However, Boosting could generate a combined model with lower errors as it optimises the advantages and reduces pitfalls of the single model.

By contrast, if the difficulty of the single model is over-fitting, then Bagging is the best option. Boosting for its part doesn’t help to avoid over-fitting; in fact, this technique is faced with this problem itself. For this reason, Bagging is effective more often than Boosting.

bagging和boosting的相同点和区别

相同点不一样点

1.二者都是集成类机器学习算法 bagging的每一个分类器是独立的，boosting每一个分类器不是独立的，下个分类器决策依赖上个分类器

2.都采用随机抽样 boosting抽样会加大错误数据权重

3.都采用投票机制来预测数据 bagging的每一个分类器权重一致，boosting的每一个分类器权重不一致，好的分类器权重更大

4.两个分类器都减小方差，增长稳定性 boosting增长准确性时也增长过分拟合，bagging能够减小过分拟合

从结构到性能，一文概述XGBoost、Light GBM和CatBoost的同与不一样

文章选自Medium，机器之心编译，原文点此跳转。

尽管近年来神经网络复兴并大为流行，可是 boosting 算法在训练样本量有限、所需训练时间较短、缺少调参知识等场景依然有其不可或缺的优点。本文从算法结构差别、每一个算法的分类变量时的处理、算法在数据集上的实现等多个方面对 3 种表明性的 boosting 算法 CatBoost、Light GBM 和 XGBoost 进行了对比；虽然本文结论依据于特定的数据集，但一般状况下，XGBoost 都比另外两个算法慢。

最近，我参加了 kaggle 竞赛 WIDS Datathon，并经过使用多种 boosting 算法，最终排名前十。从那时开始，我就对这些算法的内在工做原理很是好奇，包括调参及其优劣势，因此有了这篇文章。尽管最近几年神经网络复兴，并变得流行起来，但我仍是更加关注 boosting 算法，由于在训练样本量有限、所需训练时间较短、缺少调参知识的场景中，它们依然拥有绝对优点。

2014 年 3 月，XGBOOST 最先做为研究项目，由陈天奇提出
2017 年 1 月，微软发布首个稳定版 LightGBM
2017 年 4 月，俄罗斯顶尖技术公司 Yandex 开源 CatBoost

因为 XGBoost（一般被称为 GBM 杀手）已经在机器学习领域出现了好久，现在有很是多详细论述它的文章，因此本文将重点讨论 CatBoost 和 LGBM，在下文咱们将谈到：

算法结构差别
每一个算法的分类变量时的处理
如何理解参数
算法在数据集上的实现
每一个算法的表现

LightGBM 和 XGBoost 的结构差别

在过滤数据样例寻找分割值时，LightGBM 使用的是全新的技术：基于梯度的单边采样（GOSS）；而 XGBoost 则经过预分类算法和直方图算法来肯定最优分割。这里的样例（instance）表示观测值/样本。

首先让咱们理解预分类算法如何工做：

对于每一个节点，遍历全部特征
对于每一个特征，根据特征值分类样例
进行线性扫描，根据当前特征的基本信息增益，肯定最优分割
选取全部特征分割结果中最好的一个

简单说，直方图算法在某个特征上将全部数据点划分到离散区域，并经过使用这些离散区域来肯定直方图的分割值。虽然在计算速度上，和须要在预分类特征值上遍历全部可能的分割点的预分类算法相比，直方图算法的效率更高，但和 GOSS 算法相比，其速度仍然更慢。

为何 GOSS 方法如此高效？

在 Adaboost 中，样本权重是展现样本重要性的很好的指标。但在梯度提高决策树（GBDT）中，并无自然的样本权重，所以 Adaboost 所使用的采样方法在这里就不能直接使用了，这时咱们就须要基于梯度的采样方法。

梯度表征损失函数切线的倾斜程度，因此天然推理到，若是在某些意义上数据点的梯度很是大，那么这些样本对于求解最优分割点而言就很是重要，由于算其损失更高。

GOSS 保留全部的大梯度样例，并在小梯度样例上采起随机抽样。好比，假若有 50 万行数据，其中 1 万行数据的梯度较大，那么个人算法就会选择（这 1 万行梯度很大的数据+x% 从剩余 49 万行中随机抽取的结果）。若是 x 取 10%，那么最后选取的结果就是经过肯定分割值获得的，从 50 万行中抽取的 5.9 万行。

在这里有一个基本假设：若是训练集中的训练样例梯度很小，那么算法在这个训练集上的训练偏差就会很小，由于训练已经完成了。

为了使用相同的数据分布，在计算信息增益时，GOSS 在小梯度数据样例上引入一个常数因子。所以，GOSS 在减小数据样例数量与保持已学习决策树的准确度之间取得了很好的平衡。

高梯度/偏差的叶子，用于 LGBM 中的进一步增加

每一个模型是如何处理属性分类变量的？

CatBoost

CatBoost 可赋予分类变量指标，进而经过独热最大量获得独热编码形式的结果（独热最大量：在全部特征上，对小于等于某个给定参数值的不一样的数使用独热编码）。

若是在 CatBoost 语句中没有设置「跳过」，CatBoost 就会将全部列看成数值变量处理。

注意，若是某一列数据中包含字符串值，CatBoost 算法就会抛出错误。另外，带有默认值的 int 型变量也会默认被当成数值数据处理。在 CatBoost 中，必须对变量进行声明，才可让算法将其做为分类变量处理。

对于可取值的数量比独热最大量还要大的分类变量，CatBoost 使用了一个很是有效的编码方法，这种方法和均值编码相似，但能够下降过拟合状况。它的具体实现方法以下：

1. 将输入样本集随机排序，并生成多组随机排列的状况。

2. 将浮点型或属性值标记转化为整数。

3. 将全部的分类特征值结果都根据如下公式，转化为数值结果。

其中 CountInClass 表示在当前分类特征值中，有多少样本的标记值是「1」；Prior 是分子的初始值，根据初始参数肯定。TotalCount 是在全部样本中（包含当前样本），和当前样本具备相同的分类特征值的样本数量。

能够用下面的数学公式表示：

LightGBM

和 CatBoost 相似，LighGBM 也能够经过使用特征名称的输入来处理属性数据；它没有对数据进行独热编码，所以速度比独热编码快得多。LGBM 使用了一个特殊的算法来肯定属性特征的分割值。

注意，在创建适用于 LGBM 的数据集以前，须要将分类变量转化为整型变量；此算法不容许将字符串数据传给分类变量参数。

XGBoost

和 CatBoost 以及 LGBM 算法不一样，XGBoost 自己没法处理分类变量，而是像随机森林同样，只接受数值数据。所以在将分类数据传入 XGBoost 以前，必须经过各类编码方式：例如标记编码、均值编码或独热编码对数据进行处理。

超参数中的类似性

全部的这些模型都须要调节大量参数，但咱们只谈论其中重要的。如下是将不一样算法中的重要参数按照功能进行整理的表格。

实现

在这里，我使用了 2015 年航班延误的 Kaggle 数据集，其中同时包含分类变量和数值变量。这个数据集中一共有约 500 万条记录，所以很适合用来同时评估比较三种 boosting 算法的训练速度和准确度。我使用了 10% 的数据：50 万行记录。

如下是建模使用的特征：

月、日、星期：整型数据
航线或航班号：整型数据
出发、到达机场：数值数据
出发时间：浮点数据
到达延误状况：这个特征做为预测目标，并转为二值变量：航班是否延误超过 10 分钟
距离和飞行时间：浮点数据

import pandas as pd, numpy as np, time
from sklearn.model_selection import train_test_split

data = pd.read_csv("flights.csv")
data = data.sample(frac = 0.1, random_state=10)

data = data[["MONTH","DAY","DAY_OF_WEEK","AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT","AIR_TIME", "DEPARTURE_TIME","DISTANCE","ARRIVAL_DELAY"]]
data.dropna(inplace=True)

data["ARRIVAL_DELAY"] = (data["ARRIVAL_DELAY"]>10)*1

cols = ["AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT","ORIGIN_AIRPORT"]
for item in cols:
    data[item] = data[item].astype("category").cat.codes +1

train, test, y_train, y_test = train_test_split(data.drop(["ARRIVAL_DELAY"], axis=1), data["ARRIVAL_DELAY"],
                                                random_state=10, test_size=0.25)

XGBoost

import xgboost as xgb
from sklearn import metrics

def auc(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
                            metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

# Parameter Tuning
model = xgb.XGBClassifier()
param_dist = {"max_depth": [10,30,50],
              "min_child_weight" : [1,3,6],
              "n_estimators": [200],
              "learning_rate": [0.05, 0.1,0.16],}
grid_search = GridSearchCV(model, param_grid=param_dist, cv = 3, 
                                   verbose=10, n_jobs=-1)
grid_search.fit(train, y_train)

grid_search.best_estimator_

model = xgb.XGBClassifier(max_depth=50, min_child_weight=1,  n_estimators=200,\
                          n_jobs=-1 , verbose=1,learning_rate=0.16)
model.fit(train,y_train)

auc(model, train, test)

Light GBM

import lightgbm as lgb
from sklearn import metrics

def auc2(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict(train)),
                            metrics.roc_auc_score(y_test,m.predict(test)))

lg = lgb.LGBMClassifier(silent=False)
param_dist = {"max_depth": [25,50, 75],
              "learning_rate" : [0.01,0.05,0.1],
              "num_leaves": [300,900,1200],
              "n_estimators": [200]
             }
grid_search = GridSearchCV(lg, n_jobs=-1, param_grid=param_dist, cv = 3, scoring="roc_auc", verbose=5)
grid_search.fit(train,y_train)
grid_search.best_estimator_

d_train = lgb.Dataset(train, label=y_train)
params = {"max_depth": 50, "learning_rate" : 0.1, "num_leaves": 900,  "n_estimators": 300}

# Without Categorical Features
model2 = lgb.train(params, d_train)
auc2(model2, train, test)

#With Catgeorical Features
cate_features_name = ["MONTH","DAY","DAY_OF_WEEK","AIRLINE","DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT"]
model2 = lgb.train(params, d_train, categorical_feature = cate_features_name)
auc2(model2, train, test)

CatBoost

在对 CatBoost 调参时，很难对分类特征赋予指标。所以，我同时给出了不传递分类特征时的调参结果，并评估了两个模型：一个包含分类特征，另外一个不包含。我单独调整了独热最大量，由于它并不会影响其余参数。

import catboost as cb
cat_features_index = [0,1,2,3,4,5,6]

def auc(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
                            metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

params = {'depth': [4, 7, 10],
          'learning_rate' : [0.03, 0.1, 0.15],
         'l2_leaf_reg': [1,4,9],
         'iterations': [300]}
cb = cb.CatBoostClassifier()
cb_model = GridSearchCV(cb, params, scoring="roc_auc", cv = 3)
cb_model.fit(train, y_train)

With Categorical features
clf = cb.CatBoostClassifier(eval_metric="AUC", depth=10, iterations= 500, l2_leaf_reg= 9, learning_rate= 0.15)
clf.fit(train,y_train)
auc(clf, train, test)

With Categorical features
clf = cb.CatBoostClassifier(eval_metric="AUC",one_hot_max_size=31, \
                            depth=10, iterations= 500, l2_leaf_reg= 9, learning_rate= 0.15)
clf.fit(train,y_train, cat_features= cat_features_index)
auc(clf, train, test)

结语

为了评估模型，咱们应该同时考虑模型的速度和准确度表现。

请记住，CatBoost 在测试集上表现得最好，测试集的准确度最高（0.816）、过拟合程度最小（在训练集和测试集上的准确度很接近）以及最小的预测和调试时间。但这个表现仅仅在有分类特征，并且调节了独热最大量时才会出现。若是不利用 CatBoost 算法在这些特征上的优点，它的表现效果就会变成最差的：仅有 0.752 的准确度。所以咱们认为，只有在数据中包含分类变量，同时咱们适当地调节了这些变量时，CatBoost 才会表现很好。

第二个使用的是 XGBoost，它的表现也至关不错。即便不考虑数据集包含有转换成数值变量以后能使用的分类变量，它的准确率也和 CatBoost 很是接近了。可是，XGBoost 惟一的问题是：它太慢了。尤为是对它进行调参，很是使人崩溃（我用了 6 个小时来运行 GridSearchCV——太糟糕了）。更好的选择是分别调参，而不是使用 GridSearchCV。

最后一个模型是 LightGBM，这里须要注意的一点是，在使用 CatBoost 特征时，LightGBM 在训练速度和准确度上的表现都很是差。我认为这是由于它在分类数据中使用了一些修正的均值编码方法，进而致使了过拟合（训练集准确率很是高：0.999，尤为是和测试集准确率相比之下）。但若是咱们像使用 XGBoost 同样正常使用 LightGBM，它会比 XGBoost 更快地得到类似的准确度，若是不是更高的话（LGBM—0.785, XGBoost—0.789）。

最后必须指出，这些结论在这个特定的数据集下成立，在其余数据集中，它们可能正确，也可能并不正确。但在大多数状况下，XGBoost 都比另外两个算法慢。

python风控建模实战lendingClub(博主录制，catboost，lightgbm建模，2K超清分辨率)

https://study.163.com/course/courseMain.htm?courseId=1005988013&share=2&shareId=400000000398149

微信扫二维码，免费学习更多python资源