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

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

adaboost(adaptive boost)

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

bootsting和bagging有一些小区别，

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

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

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

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 one

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

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

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

1、集成学习概述

1.1 集成学习概述

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

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

1.3、集成学习中弱分类器选择 
一般采用弱分类器的原因在于将误差进行均衡，因为一旦某个分类器太强了就会造成后面的结果受其影响太大，严重的会导致后面的分类器无法进行分类。常用的弱分类器可以采用误差率小于0.5的，比如说逻辑回归、SVM、神经网络。

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

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

2、Boosting算法

2.1 基本概念

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

2.2、Adaboost

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

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

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

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

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

4、分类器的组合

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

5、Adaboost的一些问题

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

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

3、Bagging算法

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

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

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

1、从训练数据中选取n个数据作为训练数据输入，一般情况下n是远小于整体的训练数据N的，这样就会造成有一部分数据是无法被去到的，这部分数据称为袋外数据，可以使用袋外数据做误差估计。

2、选取了输入的训练数据的之后，需要构建决策树，具体方法是每一个分裂结点从整体的特征集M中选取m个特征构建，一般情况下m远小于M。

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

4、 重复第2步和第3步多次，每一次输入数据对应一颗决策树，这样就得到了随机森林，可以用来对预测数据进行决策。

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

随机森林算法图示

随机森林算法的注意点：

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

随机森林有很多的优点：

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

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

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

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

e. 训练速度快，可以得到变量重要性排序。

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

g 容易做成并行化方法。

h. 实现比较简单。

一、主要目的

虽然大多数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 /

二、梯度提升算法

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

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

我们希望我们的预测，使我们的损失函数（MSE）最小。 通过使用梯度下降和基于学习速率更新我们的预测，我们可以找到MSE最小的值。

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

三、梯度提升背后的直觉

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

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

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

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

因此，梯度提升算法的直觉就是反复利用残差模式，加强预测能力较弱的模型，使其更好。 一旦我们达到残差没有任何模式可以建模的阶段，我们可以停止建模残差（否则可能导致过度拟合）。 在算法上，我们正在最小化我们的损失函数，使得测试损失达到最小值。

综上所述，

• 我们首先用简单的模型对数据进行建模，并分析错误的数据。

• 这些错误通过一个简单的模型来表示数据点是很难的。

• 那么对于以后的模型，我们特别关注那些难以处理的数据，以使它们正确。

• 最后，我们通过给每个预测变量赋予一些权重来组合所有的预测变量。

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

四、拟合梯度提升模型的步骤

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

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

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

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

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

3、将误差残差的新模型作为具有相同输入变量的目标变量[称为e1_predicted]

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

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

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

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

六、工作梯度提升树的可视化

蓝点（左）是输入（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 都比另外两个算法慢。