一、决策树

1、概述

决策树是一种树形结构，树中每个内部节点表示一个特征上的判断，每个分支代表一个判断结果的输出，每个叶子节点代表一种分类结果

决策树的建立过程：

• 特征选择：选择有较强分类能力的特征
• 决策树生成：根据选择的特征生成决策树
• 决策树也容易过拟合，需要采用剪枝的方式来缓解过拟合

2、ID3决策树

(一)、信息熵

(1)、概述

熵：信息论中代表随机变量不确定度的度量

熵越大，数据的不确定性越高，信息就越多

熵越小，数据的不确定性越低

(2)、计算

一般计算时是计算目标值的信息熵。
$$\begin{gathered} H(x)=-\sum _{i=0}^{m}P(x_i)lo{g}_{2}P(x_i) \\ 其中P(x_i)表示的是数据中类别出现的概率，H(x)表示信息的信息熵值 \end{gathered}$$

例一：α为(ABCDEFGH)，计算其信息熵
$$H(\alpha )=-\sum _{i=0}^{m}P(x_i)lo{g}_{2}P(x_i)=(-\frac{1}{8}lo{g}_2\frac{1}{8})\ast 8=3$$
例二：α为(AAAABBCD)，计算其信息熵
$$H(\alpha )=-\sum _{i=0}^{m}P(x_i)lo{g}_{2}P(x_i)=(-\frac{1}{2}lo{g}_2\frac{1}{2})+(-\frac{1}{4}lo{g}_2\frac{1}{4})+(-\frac{1}{8}lo{g}_2\frac{1}{8})=\frac{1}{2}\ast 1+\frac{1}{4}\ast 2+\frac{1}{8}\ast 3\ast 2=1.75$$

(二)、信息增益

(1)、概述

特征a对训练集D的信息增益Gain(D,a)或者g(D,a)，定义为集合D的熵H(D)与特征a给定条件下的熵H(D|a)之差。

特征a而使得对数据D的分类不确定性减少的程度。

(2)、计算

$$\begin{gathered} Gain(D,a)=H(D)-H(D|a) \\ 信息增益=熵-条件熵 \end{gathered}$$

那么问题来了，条件熵该怎么计算呢：
$$H(D|a)=\sum _{i=0}^n\frac{D^i}{D}H(D^i)=\sum _{i=0}^n\frac{D^i}{D}\sum _{j=0}^m\frac{c^{ij}}{D^i}lo{g}_2\frac{c^{ij}}{D^i}$$
通俗的来说就是先求某一项特征中每一项的概率，再分别乘上该项在特征中的占比，求出该特征所有的项再求和，就获得了条件熵。

例一：已知有六个样本，根据特征a可以分为α和β两部分。α部分对应值为A，A，A，B；β部分对应值为B，B。
$$\begin{gathered} 条件为\alpha 的熵为：-\frac{3}{4}lo{g}_2\frac{3}{4}-\frac{1}{4}lo{g}_2\frac{1}{4}=0.81 \\ 条件为\beta 的熵为：-\frac{2}{2}lo{g}_2\frac{2}{2}=0 \\ 条件熵：\alpha 部分占比\frac{4}{6},\beta 部分占比\frac{2}{6} \\ \frac{4}{6}\ast 0.81+\frac{2}{6}\ast 0=0.54 \\ 熵为：-\frac{3}{6}lo{g}_2\frac{3}{6}-\frac{3}{6}lo{g}_2\frac{3}{6}=1 \\ 信息增益：熵-条件熵：1.0-0.54=0.46 \end{gathered}$$

(三)、总结

ID3决策树构建流程

• 计算每个特征的信息增益
• 使用信息增益最大的特征将数据分为子集
• 使用这个信息增益最大的特征作为当前决策树的节点
• 对剩下的特征重复上述操作，直到结束或者达到条件

3、C4.5决策树

(一)、信息增益率

(1)、概述

特征的信息增益除以特征的内在信息，相当于对信息增益进行修正，增加一个惩罚系数。特征取值个数较多时，惩罚系数较小，反正较大。

惩罚系数为数据集D以特征a作为随机变量的熵的倒数。

(2)、计算

$$\begin{gathered} Gain\_Ratio(D,a)=\frac{Gain(D,a)}{IV(a)} \\ Gain\_Ratio(D,a)就是信息增益率 \\ IV(a)=-\sum _{i=1}^n\frac{D^i}{D}lo{g}_2(\frac{D^i}{D}) \\ IV(a)为特征熵 \end{gathered}$$

例如：

特征b	特征a	目标值
1	α	A
2	α	A
3	β	B
4	α	A
5	β	B
6	α	B

$$\begin{gathered} 特征a的信息增益率： \\ 信息增益：(-\frac{3}{6}lo{g}_2\frac{3}{6}-\frac{3}{6}lo{g}_2\frac{3}{6})-(\frac{4}{6}\ast (-\frac{3}{4}lo{g}_2\frac{3}{4}-\frac{1}{4}lo{g}_2\frac{1}{4})-\frac{2}{6}\ast (0))=1-0.54=0.46 \\ IV信息熵：-\frac{4}{6}lo{g}_2\frac{4}{6}-\frac{2}{6}lo{g}_2\frac{2}{6}=0.92 \\ 信息增益率：信息增益/信息熵=0.46/0.96=0.5 \\ 特征b的信息增益率： \\ 信息增益：-\frac{3}{6}lo{g}_2\frac{3}{6}-\frac{3}{6}lo{g}_2\frac{3}{6}-6\ast 0=1 \\ IV信息熵：-\frac{1}{6}lo{g}_2\frac{1}{6}\ast 6=0.58 \\ 信息增益率：信息增益/信息熵=1/2.58=0.39 \end{gathered}$$

选择信息增益率更大的作为分裂特征。

(二)、总结

信息增益偏向于选择种类多的特征作为分裂依据，而信息增益率的出现可以很好的缓解ID3树中存在的不足。

信息增益率 = 信息增益 /特征熵。相当于对信息增益进行修正，增加了一个惩罚系数，也就是特征熵的倒数。

4、CART决策树

(一)、概述

classification and regression tree，cart模型是一种决策树模型，它可以做分类，也可以用于回归。cart回归树使用平均误差最小化策略；cart分类生成树采用的是基尼指数最小化的策略。

(二)、基尼值Gini(D)

从数据集D中随机抽取两个样本，其类别标记不一致的概率，Gini(D)值越小，数据集D的纯度越高。
$$Gini(D)=\sum _{k=1}^n\sum _{k^{,}\ne k}{p}_k{p}_k^{,}=1-\sum _{k=1}{p}_k^2$$

(三)、基尼指数(Gini_index(D))

选择使划分后基尼系数最小的属性作为最优化分属性。
$$Gin{i}_{i}ndex(D,a)=\sum _{i=1}^n\frac{D^i}{D}Gini(D^i)$$

5、ID3、C4.5、CART对比

名称	提出时间	分支方式	特点
ID3	1975	信息增益	1.ID3只能对离散属性的数据集构成决策树 2.倾向于选择取值较多的属性
C4.5	1993	信息增益率	1.缓解了ID3分支过程中总喜欢偏向选择值较多的属性 2.可处理连续数值型属性，也增加了对缺失值的处理方法 3.只适合于能够驻留于内存的数据集,大数据集无能为力
CART	1984	基尼指数	1.可以进行分类和回归，可处理离散属性，也可以处理连续属性 2.采用基尼指数，计算量减小 3.一定是二叉树

相关API

6、CART回归决策树

(一)、回归树和分类树的区别

CART 分类树预测输出的是一个离散值，CART 回归树预测输出的是一个连续值

CART 分类树使用基尼指数作为划分、构建树的依据，CART 回归树使用平方损失

分类树使用叶子节点多数类别作为预测类别，回归树则采用叶子节点里均值作为预测输出

(二)、损失函数

$$\begin{gathered} Loss(y,f(x))=(f(x)-y{)}^2 \\ f(x)为预测值，y为目标值 \end{gathered}$$

(三)、计算

将特征的值排序，取相邻元素的均值作为划分点，，计算每一个划分点的平方损失，比如下例：

x为特征，y为目标值，先将x取相邻元素的均值作为划分点

先以1.5作为分割点，将原本的数据集分为1和2-10，左子树为1，均值为5.56，右子树为2-10，均值为7.5。

计算出该划分点的平方损失为L(1.5)=(5.56-5.56)²+[(5.7-7.5)²+…+(9.05-7.5)²]=15.72

依次遍历分割点得到所有的划分点的平方损失，得到

可以得到在6.5的位置时，平方损失最小，因此以该点作为划分点，将原数据集划分成两份。

对左右子树重复上述的操作，直到叶子节点或者达到目标深度或节点数为止。

(四)、总结

• 选择一个特征，将该特征的值进行排序，取相邻点计算均值作为待划分点
• 根据所有划分点，将数据集分成两部分：R1、R2
• R1 和 R2 两部分的平方损失相加作为该切分点平方损失
• 取最小的平方损失的划分点，作为当前特征的划分点
• 以此计算其他特征的最优划分点、以及该划分点对应的损失值
• 在所有的特征的划分点中，选择出最小平方损失的划分点，作为当前树的分裂点

7、剪枝

(一)、概述

是决策树学习算法应对过拟合的一种手段。

一般是将一棵子树的子节点全部删掉，用 叶子节点去替换子树(实质是后剪枝)，甚至可以只保留根节点然后删除所有的叶子。

(二)、方式以及区别

(1)、预剪枝：

在决策树生成的过程中，对每个节点在划分钱先进行评估，如果当前节点不能带来决策树的泛化性能提升，就停止划分，并且将当前节点标记为叶节点。

优点：

• 预剪枝在树生成过程中，在树展开之前就可以判断是否剪枝，降低过拟合风险
• 显著减少计算时间和资源

缺点：

• 有些划分当前虽然不能提升泛化性能，甚至是泛化性能下降，但是在其基础上进行的后续划分可能会使性能提高
• 会给决策树带来欠拟合风险

(2)、后剪枝：

先生成一颗完整的决策树，然后自底而上的对非叶子节点进行考察，如果将当前节点的子树替换为叶节点可以为决策树带来泛化能力的提升，就将该子树替换为叶节点。

优点：

• 保留更多的分支，一般情况下，后剪枝的决策树欠拟合风险很小，泛化性能往往优于预剪枝。

缺点：

• 后剪枝过程使在生成完决策树之后进行的，要自底而上的对树所有非叶子节点考察，再进行剪枝，所以耗费的资源和时间比较大。

二、集成学习

1、概述

集成学习是机器学习的一种思想，通过多个模型的组合形成一个精度更高的模型，参与组合的模型是弱学习器(基学习器)。在训练时，使用训练集依次训练这些弱学习器，对未知样本进行预测时，弱学习器对其进行联合预测。

传统机器学习算法的目标都是找一个最优的分类器尽可能的将训练数据分开。集成学习算法的基本思想就是将多个分类器组合，从而实现一个预测效果更好的集成分类器。

集成学习通过建立几个模型来解决单一预测问题。它的工作原理是 生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。

2、分类

(一)、Bagging

通过有放回的抽样产生不同的训练集，从而训练出有差异性的弱学习器，然后通过平权投票、多数服从少数的方式来决定预测结果。

(二)、Boosting

Bagging是一种提升的思想，每一个训练器重点关注前一个训练器不足的地方进行训练，通过加权投票的方式，获得预测结果。

Bagging是一组可以将弱学习器升级为强学习器的算法，步骤如下：

• 先从初始训练集训练出一个基学习器
• 根据基学习器的表现对训练样本分布进行调整，让先前学习器做错的训练集在后续样本上获得较大关注
• 基于调整后的样本分布来训练下一个基学习器
• 重复上述三步，直到学习器的数目达到指定的值为止
• 将这T个基学习器加权得到集成学习器

每新加入一个弱学习器，整体能力就会得到提升。

(三)、区别

Bagging：

• 有放回的采样
• 平权投票
• 学习是并行的状态，每个学习器之间没有依赖关系

Boosting：

• 全部数据集，每次重点关注上一个弱学习器预测错误的值
• 加权投票
• 学习是串行的状态，学习有先后的顺序

3、随机森林

(一)、概述

是一种Bagging思想实现的一种学习算法，它采用决策树模型作为每一个基学习器。

(二)、构建

训练：

• 有放回的产生训练样本，具体来说就是每次从原来的N个训练样本中有放回地随机抽取m个样本(包括可能重复样本)。
• 随机挑选n个特征(n小于总特征数)，作为当前节点下决策的备选特征，从这些特征中选择最好地划分训练样本的特征。用每个样本集作为训练样本构造决策树。单个决策树在产生样本集和确定特征后，使用CART算法(默认)计算，不剪枝。

预测：

• 得到所需数目的决策树后，平权投票，多数表决出一个树，作为随机森林的决策。

(三)、一些注意事项

• 随机森林对训练样本进行了采样，同时对特征进行采样，充分保证构建的每个数之间的独立性，使投票更准确。

• 随机森林的随机性体现在每棵树的训练样本都是随机的，树中每个节点的分裂样本也是随机选择的，有这两个随机因素，即使每棵决策树都没有剪枝，随机森林也不会出现过拟合的现象。

• 森林中的树的数量一般取值较大，抽取的属性值需要小于总特征数。

思考

1. 为什么要随机抽样训练集？

如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样。

2. 为什么要有放回地抽样？

如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”，也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。

(四)、相关api

导包：

from sklearn.ensemble import RandomForestClassifier

调用：

RandomForestClassifier()

n_estimators：决策树数量，(default = 10)

Criterion：entropy、或者 gini, (default = gini)

max_depth：指定树的最大深度，(default = None 表示树会尽可能的生长)

max_features="auto”, 决策树构建时使用的最大特征数量

• If “auto”, then max_features=sqrt(n_features).
• If “sqrt”, then max_features=sqrt(n_features)(same as “auto”).
• If “log2”, then max_features=log2(n_features).
• If None, then max_features=n_features.

bootstrap：是否采用有放回抽样，如果为 False 将会使用全部训练样本，(default = True)

min_samples_split： 结点分裂所需最小样本数，(default = 2)

• 如果节点样本数少于min_samples_split，则不会再进行划分.
• 如果样本量不大，不需要设置这个值.
• 如果样本量数量级非常大，则推荐增大这个值.

min_samples_leaf： 叶子节点的最小样本数，(default = 1)

• 如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝.
• 较小的叶子结点样本数量使模型更容易捕捉训练数据中的噪声.

min_impurity_split: 节点划分最小不纯度

• 如果某节点的不纯度(基尼系数，均方差)小于这个阈值，则该节点不再生成子节点，并变为叶子节点.
• 一般不推荐改动默认值1e-7。

4、adaboost

(一)、概述

是一种自适应提升的算法，基于Boosting思想实现的一种集成学习算法，核心思想使通过逐步提高那些被前一步分类错误的样本的权重来训练一个强分类器。弱分类器的性能比随机猜测强就行，就可以构造出一个非常准确的强分类器。

训练时，样本具有权重，并且在训练过程中动态调整，被分错的样本会增加权重，算法会更加关注难分的样本。

构建的树不能过深，否则很容易过拟合。

(二)、构建

权值调整：

AdaBoost算法提高那些被前一轮基分类器错误分类的样本的权值，降低那些被正确分类样本的权值，从而使得那些没被正确分类的样本由于权值的加大而受到后一轮基分类器的更大关注。

**基分类器组合：**采用加权多数表决的方法

分类误差率较小的弱分类器的权值大，在表决中起较大作用

分类误差率较大的弱分类器的权值小，在表决中起较小作用

(三)、算法推导

$$\begin{gathered} H(x)=sign(\sum _{i=1}^m{\alpha }_i{h}_i(x)) \\ \alpha 为模型的权重 \\ m为弱学习器的数量 \\ {h}_i(x)表示第i个弱学习器 \\ H(x)输出结果大于0就归于正类，小于0就归于负类 \end{gathered}$$

在初始化训练数据时，各项权重相同，开始训练第一个学习器，根据预测结果找一个错误率最小的分裂点计算并更新样本权重和模型权重。根据第一个弱学习器的新权重样本集再次训练第二个弱学习器，重复上诉更新权重动作，直到训练到第m个弱学习器为止。

adaboost模型权重更新公式：
$$\begin{gathered} {\alpha }_i=\frac{1}{2}In(\frac{1-{ϵ}_i}{{ϵ}_i}) \\ {ϵ}_i表示第i个弱学习器的错误率 \\ {ϵ}_i计算：预测错误的权重和 \end{gathered}$$
adaboost样本权重更新公式：
$$\begin{gathered} D_{i+1}(x)=\frac{D_i(x)}{Z_i}\ast \{\begin{array}{l}{e}^{-{\alpha }_i},预测值=真实值\\ e^{{\alpha }_i},预测值\ne 真实值\end{array} \\ {Z}_i为归一化值，是所有样本权重总和 \\ {D}_i(x)为第i个样本权重 \\ {\alpha }_i为第i个模型的权重 \end{gathered}$$

(四)、举例构建过程

下面为训练数数据，假设弱分类器由 x 产生，其阈值 v 使该分类器在训练数据集上的分类误差率最低，试用 Adaboost 算法学习一个强分类器。

• 构建第一个弱学习器

1. 初始化工作：初始化 10 个样本的权重，每个样本的权重为：0.1

2. 构建第一个基学习器：

   1. 寻找最优分裂点

      1. 对特征值 x 进行排序，确定分裂点为：0.5、1.5、2.5、3.5、4.5、5.5、6.5、7.5、8.5
      2. 当以 0.5 为分裂点时，有 5 个样本分类错误
      3. 当以 1.5 为分裂点时，有 4 个样本分类错误
      4. 当以 2.5 为分裂点时，有 3 个样本分类错误
      5. 当以 3.5 为分裂点时，有 4 个样本分类错误
      6. 当以 4.5 为分裂点时，有 5 个样本分类错误
      7. 当以 5.5 为分裂点时，有 4 个样本分类错误
      8. 当以 6.5 为分裂点时，有 5 个样本分类错误
      9. 当以 7.5 为分裂点时，有 4 个样本分类错误
      10. 当以 8.5 为分裂点时，有 3 个样本分类错误
      11. 最终，选择以 2.5 作为分裂点，计算得出基学习器错误率为：3/10=0.3

   2. 计算模型权重: 1/2 * np.log((1-0.3)/0.3)=0.4236

   3. 更新样本权重：

      1. 分类正确样本为：1、2、3、4、5、6、10 共 7 个，其计算公式为：e^-α_t，则正确样本权重变化系数为：e^-0.4236 = 0.6547
      2. 分类错误样本为：7、8、9 共 3 个，其计算公式为：e^α_t，则错误样本权重变化系数为：e^0.4236 = 1.5275
      3. 样本 1、2、3、4、5、6、10 权重值为：0.06547
      4. 样本 7、8、9 的样本权重值为：0.15275
      5. 归一化 Z_t 值为：0.06547 * 7 + 0.15275 * 3 = 0.9165
      6. 样本 1、2、3、4、5、6、10 最终权重值为： 0.07143
      7. 样本 7、8、9 的样本权重值为：0.1667

   4. 此时得到：
      

• 构建第二个弱学习器

1. 寻找最优分裂点：

   1. 对特征值 x 进行排序，确定分裂点为：0.5、1.5、2.5、3.5、4.5、5.5、6.5、7.5、8.5

   2. 当以 0.5 为分裂点时，有 5 个样本分类错误，错误率为：0.07143 * 5 = 0.35715

   3. 当以 1.5 为分裂点时，有 4 个样本分类错误，错误率为：0.07143 * 1 + 0.16667 * 3 = 0.57144

   4. 当以 2.5 为分裂点时，有 3 个样本分类错误，错误率为：0.16667 * 3 = 0.57144

      。。。 。。。

   5. 当以 8.5 为分裂点时，有 3 个样本分类错误，错误率为：0.07143 * 3 = 0.21429

   6. 最终，选择以 8.5 作为分裂点，计算得出基学习器错误率为：0.21429

2. 计算模型权重：1/2 * np.log((1-0.21429)/0.21429)=0.64963

3. 分类正确的样本：1、2、3、7、8、9、10，其权重调整系数为：0.5222

4. 分类错误的样本：4、5、6，其权重调整系数为：1.9148

5. 分类正确样本权重值：

   1. 样本 0、1、2、、9 为：0.0373
   2. 样本 6、7、8 为：0.087

6. 分类错误样本权重值：0.1368

7. 归一化 Z_t 值为：0.0373 * 4 + 0.087 * 3 + 0.1368 * 3 = 0.8206

8. 最终权重：

   1. 样本 0、1、2、9 为 ：0.0455
   2. 样本 6、7、8 为：0.1060
   3. 样本 3、4、5 为：0.1667

9. 此时得到：
   
   

• 构建第三个弱学习器

错误率：0.1820，模型权重：0.7514

• 强学习器
  

(五)、相关api

导包：

from sklearn.ensemble import AdaBoostClassifier

调用：

mytree = DecisionTreeClassifier(criterion=‘entropy’, max_depth=1, random_state=0)

先构建一颗ID3决策树

myada = AdaBoostClassifier(base_estimator=mytree, n_estimators=500, learning_rate=0.1, random_state=0)

将基学习器设置为上面构建出的决策树，设置500棵，学习率为0.1

5、GBDT

(一)、概述

梯度提升树(Gradient Boosting Decision Tree)是boosting树的一种。

(二)、算法推导

传统提升树使用的是拟合残差，而梯度提升树利用最速下降的近似方法，利用损失函数的负梯度作为树算法的残差近似值。

计算拟合负梯度：
$$\begin{gathered} \frac{\partial L(y,f(x))}{\partial f(x_i)}=f(x_i)-y_i \\ -[\frac{\partial L(y,f(x))}{\partial f(x_i)}]=y_i-f(x_i) \\ {y}_i为目标值，f(x_i)为预测值 \end{gathered}$$
计算预测值：
$$\begin{gathered} 损失函数：L(y,f(x))=\frac{1}{2}\sum _{i=1}^n(y_i-f(x_i){)}^2 \\ 为求最小值，对损失函数求导：\frac{\partial L(y,f(x))}{\partial f(x_i)}=\sum _{i=1}^n(y_i-f(x_i))\ast (y_i-f(x_i){)}^{‘} \\ =\sum _{i=1}^n(y_i-f(x_i))\ast (-1) \\ =\sum _{i=1}^n(-y_i+f(x_i))=0 \\ 整理得到：f(x_i)=\frac{{\sum }_{i=1}^n{y}_i}{n} \\ {y}_i为目标值，f(x_i)为预测值 \\ 注意此处的预测值在第一次时都一样，后续被切分点分为左子树和右子树，左子树预测值相同，右子树预测值相同 \end{gathered}$$
计算每个切分点的平方损失，找到平方损失的切分点，以此切分，得到第一棵决策树；将负梯度值传递给下一棵树作为目标值，再次重复计算切分点平方损失，找到切分点，得到第二棵决策树。

(三)、举例

原始数据：

利用
$$\begin{gathered} f(x_i)=\frac{{\sum }_{i=1}^n{y}_i}{n} \\ \frac{\partial L(y,f(x))}{\partial f(x_i)}=f(x_i)-y_i \\ -[\frac{\partial L(y,f(x))}{\partial f(x_i)}]=y_i-f(x_i) \\ {y}_i为目标值，f(x_i)为预测值 \end{gathered}$$
计算样本的负梯度为

当1.5为切分点：拟合负梯度-1.75, -1.61, -1.40, -0.91, … , 1.74

左子树：1个样本 -1.75， 右子树9个样本：-1.61，-1.40，-0.91…

右子树均值为：((-1.61) + (-1.40)+(-0.91)+(-0.51)+(-0.26)+1.59 +1.39 + 1.69 + 1.74 )/9=0.19；

左子树均值为：- 1.75

计算平方损失：左子树0 + 右子树：(-1.61-0.19)2 + (-1.40-0.19)2 + (-0.91-0.19)2 + (-0.51-0.19)2 +(-0.26-0.19)2 + (1.59-0.19)2 + (1.39-0.19)2 + (1.69-0.19)2 + (1.74-0.19)2 =15.72308

按照这个方式依次计算切分点值得到：

得到在6.5处切分最佳，得到左右子树，此时构建第二个弱学习器：

之前的负梯度就是该学习器的目标值，再利用公式计算左右树的预测值(左右树的均值)，再次求负梯度和平方损失。

在3.5处作为切分点，得到第二棵决策树，重复以上动作，直到完成次数为止。下面是第二次计算完成，得出在6.5处切割。

第三次切割完成，我们假设三次就结束，以x=6样本为例，最终的学习器中的结果就是：7.31 + (-1.07) + 0.22 + 0.15 = 6.61

-1.07是第一棵决策树输出结果，0.22是第二棵决策树输出结果，0.15是第三棵决策树输出结果，初始值加上这些输出值，得到最后值。

(四)、相关api

导包：

from sklearn.tree import DecisionTreeClassifier

from sklearn.ensemble import GradientBoostingClassifier

调用：

estimator = GradientBoostingClassifier()

网格交叉：

estimator = GradientBoostingClassifier()

param = {“n_estimators”: [100, 110, 120, 130], “max_depth”: [2, 3, 4], “random_state”: [9]}

estimator = GridSearchCV(estimator, param_grid=param, cv=3)

6、XGBoost

(一)、概述

eXtreme Gradient Boosting，极端梯度提升树，集成学习的王牌。

构建模型的方式为从最小化训练数据的损失函数
$$min\frac{1}{N}\sum _{i+1}^{N}L(y_i,\widehat{y_i})$$
训练的模型复杂度会较高，很容易过拟合。可以在损失函数中加入正则化项。
$$min\frac{1}{N}\sum _{i+1}^{N}L(y_i,\widehat{y_i})+\Omega (f)$$
提高对未知的测试数据的泛化性能。

总体来说XGBoost是对GBDT的改进，在损失函数中加入了正则化项。
$$\begin{gathered} obj(\varphi )=\sum _i^{n}L(y_i,\widehat{y_i})+\sum _{k=1}^K\Omega (f_k) \\ \Omega (f)=\gamma T+\frac{1}{2}\lambda ||w|{|}^2 \\ T表示一棵树的叶子节点数量，\Omega (f)是模型复杂度，obj(\varphi )是目标函数 \\ w表示叶子节点输出值组成的向量，||w||是向量的模，\lambda 对该项的调节系数 \end{gathered}$$

(二)、算法推导

$$\begin{gathered} obj(\varphi )=\sum _i^{n}L(y_i,\widehat{y_i})+\sum _{k=1}^K\Omega (f_k) \\ \Omega (f)=\gamma T+\frac{1}{2}\lambda ||w|{|}^2 \\ T表示一棵树的叶子节点数量 \\ w表示叶子节点输出值组成的向量，||w||是向量的模，\lambda 对该项的调节系数 \end{gathered}$$

上述公式经过t次迭代后，目标函数如下：
$$\begin{gathered} obj(\varphi {)}^{(t)}=\sum _i^{n}L(y_i,{\widehat{y_i}}^{(t)})+\Omega (f_t) \\ =\sum _i^{n}L(y_i,{\widehat{y_i}}^{(t-1)}+f_t(x_i))+\Omega (f_t) \end{gathered}$$
由于直接求解目标函数比较困难，所以通过泰勒展开来将目标函数换成一种近似的表示方式

已知二阶泰勒展开：
$$f(x+\Delta x)\approx f(x)+f^{‘}(x)\cdot \Delta x+\frac{1}{2}{f}^{‘‘}(x)\cdot \Delta x^2$$
于是将目标公式二阶展开：
$$\begin{gathered} obj(\varphi {)}^{(t)}\approx \sum _i^n[L(y_i,{\widehat{y_i}}^{(t-1)})+g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\Omega (f_t) \\ {h}_i={\partial }_{{\hat{y}}^{t-1}}L(y_i,{\hat{y}}^{t-1}) \\ {g}_i={\partial }_{{\hat{y}}^{t-1}}^{2}L(y_i,{\hat{y}}^{t-1}) \end{gathered}$$
而损失函数是一个常数值，所以我们在下面的计算当中去掉，方便后续数据处理，因此数据修改为：
$$obj(\varphi {)}^{(t)}=\sum _i^n[g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\Omega (f_t)$$
完整式子为：
$$\begin{gathered} obj(\varphi {)}^{(t)}=\sum _i^n[g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\gamma T+\frac{1}{2}\lambda ||w|{|}^2 \\ {f}_t(x_i)表示样本的预测值，T是叶子节点的数量 \end{gathered}$$
自定义叶子节点集合，然后对上述公式做转换
$$\begin{gathered} 定义I_j为叶子节点的实例集 \\ \sum _i^n{g}_i{f}_t(x_i)=\sum _{j=1}^T(\sum _{i\in I_j}{g}_i)w_j \\ \sum _i^n\frac{1}{2}{h}_i{f}_t^2(x_i)=\sum _{j=1}^T\frac{1}{2}(\sum _{i\in I_j}{h}_i+\lambda )w_j^2 \\ \frac{1}{2}\lambda ||w|{|}^2=\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2 \\ 将转换带入后简化得： \\ obj(\varphi {)}^{(t)}=\sum _{j=1}^T[(\sum _{i\in I_j}{g}_i)w_j+\frac{1}{2}(\sum _{i\in I_j}{h}_i+\lambda )w_j^2]+\gamma T \\ 设定: \\ {G}_j=\sum _{i\in I_j}{g}_i \\ {H}_j=\sum _{i\in I_j}{h}_i \\ 得到简化式： \\ obj(\varphi {)}^{(t)}=\sum _{j=1}^T[G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2]+\gamma T \end{gathered}$$
求解到最终的损失函数，此时我们需要求解函数的最小值，因此我们对损失函数进行求导：
$$\begin{gathered} 对w_j进行求导，并且令其等于0： \\ 简化后可得：w_j=-\frac{G_j}{H_j+\lambda } \\ 将次最优解的值带入原公式： \\ obj(\varphi {)}^{(t)}=\sum _{j=1}^T[G_j(-\frac{G_j}{H_j+\lambda })+\frac{1}{2}(H_j+\lambda )(-\frac{G_j}{H_j+\lambda }{)}^2]+\gamma T \\ =\sum _{j=1}^T[-\frac{G_j^2}{H_j+\lambda }+\frac{1}{2}(\frac{G_j^2}{H_j+\lambda })]+\gamma T \\ =-\frac{1}{2}\sum _{j=1}^T(\frac{G_j^2}{H_j+\lambda })+\gamma T \end{gathered}$$
此时的公式就是函数的最优解，我们将其称为打分函数，可以从损失函数和树的复杂度两个角度来衡量一棵树的优劣。当我们构建树的时候，我们可以用这个函数来选择树的划分点：
$$\begin{gathered} Gain=ob{j}_{L+R}-(ob{j}_L+ob{j}_R) \\ =[-\frac{1}{2}\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }+\gamma T]-[-\frac{1}{2}(\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda })+\gamma (T+1)] \\ =\frac{1}{2}[\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }]-\gamma \end{gathered}$$
根据上述公式，我们可以得出：

• 对树中的每个叶子节点都尝试进行分裂
• 计算分裂前-分裂后的分数
  • 如果Gain>0，则分裂后树的损失更小，考虑此时分裂
  • 如果Gain<0，则分裂后的的损失更大，不建议分裂
• 当触发以下条件时，停止分裂：
  • 达到最大深度
  • 叶子节点数量低于设定阈值
  • 所有的节点分裂时都不能降低损失

(三)、相关api

导包：

from xgboost import XGBClassifier

调用：

estimator = XGBClassifier(n_estimators=100, objective=‘multi:softmax’,eval_metric=‘merror’, eta=0.1, use_label_encoder=False, random_state=22)

• base_score：基础分数，用于模型初始化时的分数估计，默认值为0.5。

• booster：基分类器的类型。默认值为’gbtree’，表示使用基于树的模型；还可以选择’gblinear’表示使用线性模型；在某些版本中，还支持’dart’表示使用带dropout的树模型来防止过拟合。

• objective：目标函数，用于指定模型的训练目标。对于二分类问题，默认值为’binary:logistic’（返回概率）；对于回归问题，可以使用’reg:linear’或’reg:logistic’；对于多分类问题，可以使用’multi:softmax’或’multi:softprob’。

• random_state：随机种子，用于保证结果的可复现性

• eta，也称为learning_rate: 学习率