一、集成学习思想

1. 什么是集成学习？
   集成学习是机器学习中的一种思想，它通过多个模型的组合形成一个精度更高的模型，参与组合的模型成为弱学习器（基学习器）。训练时，使用训练集依次训练出这些弱学习器，对未知的样本进行预测时，使用这些弱学习器联合进行预测，因此，集成学习不是一种新的算法，而是将机器学习的算法集成
   
2. Bagging思想：

• 有放回的抽样（booststrap抽样）产生不同的训练集，从而训练不同的学习器
• 通过平权投票、多数表决的方式决定预测结果
• 弱学习器可以并行训练
  

目标：把图中的圈和方块进行分类

3. Boosting思想：

• 每一个训练器重点关注前一个训练器不足的地方进行训练
• 通过加权投票的方式，得出预测结果
• 串行的训练方式
  

4. 对比：

	bagging	boosting
数据采样	对数据进行有放回的采样训练	全部样本，根据前一轮学习结果调整数据的重要性
投票方式	所有学习器平权投票	对学习器进行加权投票
学习顺序	并行，每个学习器没有依赖关系	串行，学习有先后顺序

二、Bagging思想——随机森林算法

1. 构建过程：

• 随机选取数据有放回抽样
• 随机选取特征
• 训练弱学习器
• 重复1-3训练n个
• 平权投票
  

2. API：
   
3. 案例：使用泰坦尼克号数据预测存活概率

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import GridSearchCV

data = pd.read_csv("train.csv")
x = data[["Pclass" , "Age" , "Sex"]]
y = data["Survived"]
x["Age"].fillna(x["Age"].mean(), inplace=True)
x = pd.get_dummies(x)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=22)
# CART树
dtc = DecisionTreeClassifier(max_depth=10 , random_state=22)
dtc.fit(x_train , y_train)
y_pre1 = dtc.predict(x_test)
accuracy_score(y_test, y_pre1)
# 随机森林
rfc = RandomForestClassifier(n_estimators=10 , max_depth=10 , random_state=22)
rfc.fit(x_train , y_train)
y_pre2 = rfc.predict(x_test)
accuracy_score(y_test, y_pre2)
# 网格搜索寻找超参数
param_grid = {"n_estimators": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] , "max_depth": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] , "min_samples_split": [2, 4, 6, 8] , "random_state": [22]}
estimator = RandomForestClassifier()
grid_search = GridSearchCV(estimator, param_grid)
grid_search.fit(x_train , y_train)
print(grid_search.best_params_)
print(grid_search.best_estimator_)
y_pre3 = grid_search.predict(x_test)
print(accuracy_score(y_test, y_pre3))

三、Boosting思想——Adaboost算法

1. Adaptive Boosting(自适应提升)基于 Boosting思想实现的一种集成学习算法核心思想是通过逐步提高那些被前一步分类错误的样本的权重来训练一个强分类器
2. 特点：训练时，样本具有权重，并且在训练过程中动态调整。被分错的样本的样本会加大权重，算法更加关注难分的样本
3. 核心步骤：

• 权值调整：AdaBoost算法提高那些被前一轮基分类器错误分类样本的权值，而降低那些被正确分类样本的权值。从而使得那些没有得到正确分类的样本，由于权重的加大而受到后一轮基分类器的更大关注
• 基分类器组合：AdaBoost采用加权多数表决的方法
  • 分类误差率较小的弱分类器的权值大，在表决中起较大作用
  • 分类误差率较大的弱分类器的权值小，在表决中起较小作用

4. 算法推导：

• 初始化训练数据权重相等，训练第1个学习器
  • 如果有100个样本，则每个样本的初始化权重为：1/100
  • 根据预测结果找一个错误率最小的分裂点，计算更新：样本权值、模型权值
• 根据新权重的样本集训练第2个学习器
• 迭代训练在前一个学习器的基础上，根据新的样本权重训练当前学习器，直到训练处m个弱学习器
• m个弱学习器集成预测公式：$\mathrm{H}(\mathrm{x})=\mathrm{sign}({\sum }_{i=1}^m{a}_i{h}_i(x))$
• 模型权重计算公式：$$a_{\mathrm{t}}=\frac{1}{2}\ln (\frac{1-{\epsilon }_t}{{\epsilon }_t})，a_{\mathrm{t}}为模型权重，{\epsilon }_t表示第t个弱学习器的错误率$$
• 样本权重计算公式：
  $${\mathrm{D}}_{\mathrm{t}+1}(x)=\frac{{\mathrm{D}}_{\mathrm{t}}(x)}{Z_t}\ast \{\begin{array}{ll}{e}^{-a_t},\text{预 测 值 }=\text{ 真 实 值 }& \\ e^{a_t},\text{预 测 值 }\approx \text{真 实 值 }& \end{array}，\{\begin{array}{l}{Z}_t为归一化值（所有样本权重的总和）\\ D_t(x)为样本权重\\ {\alpha }_t为模型权重\end{array}$$

对于数据集：

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. 计算模型权重: $a_{\mathrm{t}}=\frac{1}{2}\ln (\frac{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.6547\cdot 0.1=0.06547$
      4. 样本 7、8、9 的样本权重值为：$1.5275\cdot 0.1=0.15275$
      5. 归一化 Z_t 值为：$0.06547\cdot 7+0.15275\cdot 3=0.9165$
      6. 样本 1、2、3、4、5、6、10 最终权重值为： $\frac{0.06547}{0.9165}=0.07143$
      7. 样本 7、8、9 的样本权重值为：$\frac{0.15275}{0.9165}=0.1667$

3. 构建第二个基学习器：

   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. 以此类推
      6. 当以 8.5 为分裂点时，有 3 个样本分类错误，错误率为：0.07143 * 3 = 0.21429
      7. 最终，选择以 8.5 作为分裂点，计算得出基学习器错误率为：0.21429

   2. 计算模型权重: $a_{\mathrm{t}}=\frac{1}{2}\ln (\frac{1-0.21429}{0.21429})=0.64963$

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

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

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

      1. 样本 0、1、2、9 为：$0.5222\cdot 0.07143=0.0373$
      2. 样本 6、7、8 为：$0.5222\cdot 0.1667=0.087$

   6. 分类错误样本权重值：$1.9148\cdot 0.07143=0.1368$

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

   8. 最终权重：

      1. 样本 0、1、2、9 为 ：$\frac{0.0373}{0.8206}=0.0455$
      2. 样本 6、7、8 为：$\frac{0.087}{0.8206}=0.1060$
      3. 样本 3、4、5 为：$\frac{0.1368}{0.8206}=0.1667$

      >

4. 构建第四个基学习器：
   

5. 强学习器： $\mathrm{H}(\mathrm{x})=\mathrm{sign}(0.4236^{\star }{h}_1(x)+0.64963^{\star }{h}_2(x)+0.7515^{\star }{h}_3(x))$

5. 案例：

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
# 数据预处理
data = pd.read_csv("wine0501.csv")
data = data[data["Class label"] != 1]
x = data[["Alcohol" , "Hue"]].values
y = data["Class label"]
y = LabelEncoder().fit_transform(y)
# 划分
x_train , x_test , y_train , y_test = train_test_split(x , y , test_size = 0.2, random_state = 22)
# 训练
dtc = DecisionTreeClassifier(criterion = "entropy" , max_depth=10 , random_state = 22)
estimator = AdaBoostClassifier(estimator=dtc , n_estimators=100 , learning_rate=0.1 , random_state=22)
dtc.fit(x_train , y_train )
estimator.fit(x_train , y_train)
# 预测评估
y_pre1 = dtc.predict(x_test)
y_pre2 = estimator.predict(x_test)
print("===========dtc===========")
print(dtc.score(x_test , y_test))
print(dtc.score(x_test , y_test))
print("===========estimator===========")
print(estimator.score(x_test , y_test))
print(accuracy_score(y_test, y_pre2))

四、Boosting思想——GBDT算法

1. 提升树：通过拟合残差的思想来进行提升，其中残差：真实值 - 预测值
2. 梯度提升树：通过梯度下降的近似方法，利用损失函数的负梯度作为提升树算法中的残差近似值
3. 数学公式：

• 前一轮迭代得到的强学习器是：$f_{i-1}(x)$
• 损失函数为平方损失是：$L(y,f_{i-1}(x))$
• 本轮迭代的目标是找到一个弱学习器：$h_t(x)$
• 让本轮的损失最小化：$L(y,f_i(x))=L(y,f_{i-1}(x))+h_t(x)=(y-f_{i-1}(x)-h_t(x){)}^2$
• 则要拟合的负梯度为：$-\left[\frac{\partial \mathrm{L}(\mathrm{y},\mathrm{f}({\mathrm{x}}_{\mathrm{i}}))}{\partial \mathrm{f}({\mathrm{x}}_{\mathrm{i}})}\right]={\mathrm{y}}_{\mathrm{i}}-\mathrm{f}({\mathrm{x}}_{\mathrm{i}})$

1. 已知
2. 初始化弱学习器（CART树）：

• 当模型预测值为何值时，会使得第一个弱学习器的平方误差最小（即损失函数对$f(x_i)$的导数，并令导数为0）
  • 损失函数：$$L(y,f(x))=\frac{1}{2}\sum _{i=1}^n(y_i-f(x_i){)}^2$$
  • 求导：$$\begin{array}{r}\frac{\partial \mathrm{L}(y,\mathrm{f}(\mathrm{x}))}{\partial \mathrm{f}(x_i)}=\sum _{i=1}^n(y_i-f(x_i))\ast (y_i-f(x_i){)}^{\prime }\\ =\sum _{i=1}^n(y_i-f(x_i))\ast (-1)=\sum _{i=1}^n(-y_i+f(x_i))=0\end{array}$$
• 化简：$$\mathrm{nf}({\mathrm{x}}_{\mathrm{i}})=\sum _{i=1}^{\mathrm{n}}{y}_i⟶\mathrm{f}({\mathrm{x}}_{\mathrm{i}})=\frac{{\sum }_{i=1}^{\mathrm{n}}{y}_i}{n}$$
• 因此，初始化树桩输出值为均值时，可使得第一个弱学习器的平方误差最小
• 第一轮基学习的预测值为：（5.56+5.7+5.91+6.4+6.8+7.05+8.9+8.7+9+9.05）/10=7.31
• 负梯度（残差值）：目标值 - 预测值

3. 构建第一个弱学习器：

• 上表中平方损失计算过程说明（以切分点1.5为例）：

  1. 切分点1.5 将数据集分成两份 [5.56],[5.56 5.7 5.91 6.4 6.8 7.05 8.9 8.7 9. 9.05]

  2. 第一份的平均值为5.56 ；第二份数据的平均值为（5.7+5.91+6.4+6.8+7.05+8.9+8.7+9+9.05）/9 = 7.5011

  3. 由于是回归树，每份数据的平均值即为预测值，则可以计算误差，第一份数据的误差为0，第二份数据的平方误差为 : $(5.70-7.5011{)}^2+(5.91-7.5011{)}^2+...+(9.05-7.5011{)}^2=15.72308$

  4. 同理，依次计算2.5、3.5的平方损失
     

• 发现以6.5划分时，平方损失最小

• 因此左预测值：$f_1(x)=(-1.75-1.61-1.4-0.91-0.51-0.26)/6=-1.07$

• 因此右预测值：$f_1(x)=(1.59+1.39+1.69+1.74)/4=1.6$

• 以 6.5 作为切分点损失最小，构建决策树如下：
  

4. 构建第二个弱学习器：

• 以 3.5 作为切分点损失最小，构建决策树如下：
  

5. 构建第三个弱学习器：

• 以 6.5 作为切分点损失最小，构建决策树如下：
  

6. 构建最终弱学习器：

• 以x=6为例，最终学习器的结果为：$7.31+(-1.07)+0.22+0.15=6.61$

4. 案例：

import pandas as pd
from joblib.testing import param
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split , GridSearchCV
# 数据预处理
data = pd.read_csv("train.csv")
x = data[["Pclass" , "Age" , "Sex"]]
y = data["Survived"]
x["Age"].fillna(x["Age"].mean(), inplace=True)
x = pd.get_dummies(x)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=22)
# 网格搜索
estimator1 = GradientBoostingClassifier()
estimator1.fit(x_train, y_train)
estimator1.score(x_train, y_train)
parameters = {"n_estimators": [50, 100, 150, 200] , "max_depth": [2, 4, 6, 8 , 10] , "random_state": [22] }
estimator2 = GridSearchCV(estimator=estimator1, param_grid=parameters , cv=3)
estimator2.fit(x_train, y_train)
# 寻找超参数
print(estimator2.score(x_train, y_train))
print(estimator2.best_estimator_)

五、Boosting思想——XGBoost算法

1. XGBoost（Extreme Gradient Boosting）是对GBDT的改进，在损失函数中加入了正则化项：$$\begin{gathered} obg(\theta )=\sum _{i=1}^{N}L\left(y_i,f\left(x_i\right)\right)+\sum _{k=1}^K\Omega (f_k) \\ \Omega (f)=\gamma T+\frac{1}{2}\lambda \Vert w{\Vert }^2 \end{gathered}$$

• $\gamma T$中 T 表示一棵树的叶子结点数量
• $\lambda \Vert w{\Vert }^2$中的 w 表示叶子节点输出值组成的项链，$\Vert w\Vert$向量的模：$\lambda$对该项的调节系数

2. 公式推导：

• 由于进行 t 次迭代时，t-1 次迭代的目标函数已知，因此可以写为：
  $$\begin{array}{rl}ob{j}^{(t)}& =\sum _{i=1}^{n}L\left(y_i,{\hat{y}}_i^{(t)}\right)+\sum _{k=1}^t\Omega \left(f_k\right)\\ & =\sum _{i=1}^{n}L\left(y_i,{\hat{y}}_i^{(\mathrm{t}-1)}+f_t\left(x_i\right)\right)+\sum _{k=1}^{t-1}\Omega \left(f_k\right)+\Omega \left(f_t\right)\end{array}$$

• 泰勒公式：
  $$f(x+\Delta x)=f(x)+f^{\prime }(x)\cdot \Delta x+\frac{1}{2}{f}^{\prime \prime }(x)\cdot \Delta x^2+......+\frac{1}{n!}{f}^{(n)}(x)\cdot \Delta x^n$$

• 直接对目标函数求解比较困难，因此可以通过泰勒公式转换，将$f_t(x_i)$视为$\Delta x$：
  $$\begin{gathered} ob{j}^{(t)}\approx \sum _{i=1}^m\left[L\left(y_i,{\hat{y}}_i^{(t-1)}\right)+g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\sum _{k=1}^{t-1}\Omega \left(f_k\right)+\Omega \left(f_t\right) \\ 其中\{\begin{array}{ll}& g_i={\partial }_{{\hat{y}}^{t-1}}L\left(y_i,{\hat{y}}^{(t-1)}\right)\\ & h_i={\partial }_{{\hat{y}}^{(t-1)}}^{2}L\left(y_i,{\hat{y}}^{(t-1)}\right)\end{array} \end{gathered}$$

• 由于$L\left(y_i,{\hat{y}}_i^{(t-1)}\right)$和${\sum }_{k=1}^{t-1}\Omega (f_k)$均为 t-1 次迭代的常量，在求导时为0，因此可以忽略
  $$\begin{array}{rl}& ob{j}^{(t)}\approx \sum _{i=1}^m[L\left(y_i,{\hat{y}}_i^{(t-1)}\right)+g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\sum _{k=1}^{t-1}\Omega (f_k)+\Omega (f_t)\\ & ob{j}^{(t)}\approx \sum _{i=1}^m\left[g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\Omega \left(f_t\right)，其中\Omega (f)=\gamma T+\frac{1}{2}\lambda \Vert w{\Vert }^2\\ & ob{j}^{(t)}\approx \sum _{i=1}^m\left[g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\gamma T+\frac{1}{2}\lambda \Vert w{\Vert }^2\end{array}$$

• 因此我们就从样本角度转为按照叶子结点输出角度，在上试中

  • $g_i$表示每个样本的一阶导，$h_i$表示每个样本的二阶导
  • $f_i(x_i)$表示样本的预测值
  • T 表示叶子节点的数目
  • $\Vert w|{}^2$由叶子结点值组成向量的模

例如：10 个样本，落在 D 结点 3 个样本，落在 E 结点 2 个样本，落在 F 结点 2 个样本，落在 G 结点 3 个样本

1. D 结点计算： w1 * gi1 + w1 * gi2 + w1 * gi3 = (gi1 + gi2 + gi3) * w1

2. E 结点计算： w2 * gi4 + w2 * gi5 = (gi4 + gi5) * w2

3. F 结点计算： w3 * gi6 + w3 * gi6 = (gi6 + gi7) * w3

4. G 节点计算：w4 * gi8 + w4 * gi9 + w4 * gi10 = (gi8 + gi9 + gi10) * w4

• 由例子，我们可以尝试简化项，其中$g_i{f}_i(x_i)$：
  $$\sum _{i=1}^m{g}_i{f}_t\left(x_i\right)=\sum _{j=1}^T\left(\sum _{i\in I_j}{g}_i\right)w_j$$

• $h_i{f}_t^2(x_i)$：
  $$\sum _{i=1}^m\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)=\frac{1}{2}\sum _{j=1}^T\left(\sum _{i\in I_j}{h}_i\right)w_j^2$$

• $\lambda \Vert w{\Vert }^2$：
  $$\frac{1}{2}\lambda ||w{\Vert }^2=\frac{1}{2}\lambda \sum _{i=1}^T{w_i}^2$$

• 因此转化为叶子结点输出角度：
  $$\begin{array}{rl}ob{j}^{(t)}& \approx \sum _{i=1}^m\left[g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\gamma T+\frac{1}{2}\lambda \Vert w{\Vert }^2\\ & =\sum _{j=1}^T\left[\left(\sum _{i\in I_j}{g}_i\right)w_j+\frac{1}{2}\left(\sum _{i\in I_j}{h}_i\right)w_j^2\right]+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2\\ & =\sum _{j=1}^T\left[\left(\sum _{i\in I_j}{g}_i\right)w_j+\frac{1}{2}\left(\sum _{i\in I_j}{h}_i\right)w_j^2+\frac{1}{2}\lambda w_j^2\right]+\gamma T\\ & =\sum _{j=1}^T\left[\left(\sum _{i\in I_j}{g}_i\right)w_j+\frac{1}{2}\left(\sum _{i\in I_j}{h}_i+\lambda \right)w_j^2\right]+\gamma T\end{array}$$

• 令：
  $$\begin{gathered} G_i=\sum _{i\in I_j}{g}_i，G_i表示所有样本的一阶导之和 \\ {H}_i=\sum _{i\in I_j}{h}_i，H_i表示所有样本的二阶导之和 \end{gathered}$$

• 最终：
  $$ob{j}^{(t)}=\sum _{i=1}^T\left[G_i{w}_i+\frac{1}{2}(H_i+\lambda )w_i^2\right]+\gamma T$$

• 求导取 w 的最优质：
  $$w_i=-\frac{G_i}{H_i+\lambda }$$

• 将 w 带入目标函数求得最小值：
  $$\begin{array}{rl}ob{j}^{(t)}& =\sum _{i=1}^T\left[G_i\left(-\frac{G_i}{H_i+\lambda }\right)+\frac{1}{2}(H_i+\lambda ){\left(-\frac{G_i}{H_i+\lambda }\right)}^2\right]+\gamma T\\ & =\sum _{i=1}^T\left[G_i\left(-\frac{G_i}{H_i+\lambda }\right)+\frac{1}{2}(H_i+\lambda ){\left(-\frac{G_i}{H_i+\lambda }\right)}^2\right]+\gamma T\\ & =\sum _{i=1}^T\left[-\frac{G_i^2}{H_i+\lambda }+\frac{1}{2}\left(\frac{G_i^2}{H_i+\lambda }\right)\right]+\gamma T\\ & =-\frac{1}{2}\sum _{i=1}^T\left(\frac{G_i^2}{H_i+\lambda }\right)+\gamma T\end{array}$$

3. 打分函数 (scoring function)，它可以从树的损失函数、树的复杂度两个角度来衡量一棵树的优劣,当我们构建树时，可以用来选择树的最佳划分点：
   $$\begin{array}{rl}\mathrm{Gain}& =Ob{j}_{L+R}-(Ob{j}_L+Ob{j}_R)\\ & =\left[-\frac{1}{2}\frac{{\left(G_L+G_R\right)}^2}{H_L+H_R+\lambda }+\gamma T\right]-\left[-\frac{1}{2}\left(\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }\right)+\gamma (T+1)\right]\\ & =\frac{1}{2}\left[\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{{\left(G_L+G_R\right)}^2}{H_L+H_R+\lambda }\right]-\gamma \end{array}$$

• 打分函数的过程如下：
  1. 对树中的每个叶子结点尝试进行分裂
  2. 计算分裂前 - 分裂后的分数：
     1. 如果gain > 0，则分裂之后树的损失更小，我们会考虑此次分裂
     2. 如果gain< 0，说明分裂后的分数比分裂前的分数大，此时不建议分裂
  3. 当触发以下条件时停止分裂：
     1. 达到最大深度
     2. 叶子结点样本数量低于某个阈值
     3. 所有的节点在分裂不能降低损失

4. API：通过pip3 install xgboost获得

bst = XGBClassifier(n_estimators, max_depth, learning_rate, objective)

5. 案例：

import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.model_selection import train_test_split , StratifiedKFold , GridSearchCV
from sklearn.metrics import classification_report
from sklearn.utils import class_weight
# 数据预处理
data = pd.read_csv("红酒品质分类.csv")
x = data.iloc[:, :-1]
y = data.iloc[:, -1] - 3
x_train , x_test , y_train , y_test = train_test_split(x, y , stratify=y , test_size = 0.2, random_state = 22)
# 保存训练集和测试集
pd.concat([x_train, y_train] , axis = 1).to_csv("x_train.csv")
pd.concat([x_test, y_test] , axis = 1).to_csv("x_test.csv")
train_data = pd.read_csv("x_train.csv")
test_data = pd.read_csv("x_test.csv")
x_train = train_data.iloc[:, :-1]
y_train = train_data.iloc[:, -1]
x_test = test_data.iloc[:, :-1]
y_test = test_data.iloc[:, -1]
# 根据类别的分布自动计算权重，使得每个类别的权重与其样本数量成反比
class_weights = class_weight.compute_sample_weight(class_weight='balanced', y=y_train)
# 分层交叉验证
spliter = StratifiedKFold(n_splits=4, shuffle=True)
param_grid = {"max_depth" :np.arange(10,100,10) , "n_estimators" :np.arange(50,100,10) , "learning_rate" :np.arange(0.1,1,0.2) }
# 使用XGBoost训练模型，其中损失函数设置为多分类
estimator1 = xgb.XGBClassifier(n_estimators=100 ,
                              objective='multi:softmax' ,
                              eval_metric='merror' ,
                              eta=0.01 ,
                              random_state=22)
# 网格搜索
estimator2 = GridSearchCV(estimator=estimator1 , param_grid=param_grid,cv=spliter)
estimator2.fit(x_train , y_train)
# 预测
y_pre = estimator2.predict(x_test)
print(classification_report(y_test, y_pre))
print(estimator2.best_params_)
print(estimator2.best_score_)