Datawhale 202104 集成学习（中）| Boosting学习

1. 导论

从“方差-偏差理论”出发，Bagging通过降低方差的方式减少预测误差，Boosting通过降低偏差的方式减少误差。
两种最常用的Boosting方式：Adaptive Boosting和Gradient Boosting，此外还有他们的变体变体Xgboost、LightGBM以及Catboost。

算法模型	提升方法
Boosting
Adaboost
前向分布
梯度提升决策树（GBDT）
XGBoost

Boosting方法的基本思路

基本思路：

• 将多次错误记录下来，直到模型能够完全拟合；
• 对一个复杂任务，将多个专家的判断整合；

强可学习和弱可学习：

• 弱学习：识别错误率小钰1/2（准确率仅比随即猜测略高的学习算法）；
• 强学习：识别准确率很高并能在多项式时间内完成的学习算法；

PAC学习框架中，强可学习和若可学习是等价的。将弱可学习算法提升至强可学习算法，通过组合弱分类器构成一个强分类器。改变训练数据集的概率分布（训练数据不同样本的权值），对不同概率分布的数据调用弱分类算法学习一系列弱分类器。

Boosting方法中的两个问题：

• 每一轮学习应该如何改变数据的概率分布；
• 如何将各个弱分类器组合起来。

2. Adaboost算法

Adaboost的基本原理

Adaboost解决Boosting经典问题的方法：

• 提高被分类器错误分类样本的权重，降低正确分类样本权重；
• 各个弱分类器的组合通过采取加权多数表决的方式；

Adabosst的具体算法：

(1) 初始化训练数据的分布：$D_1=\left(w_{11},\cdots ,w_{1i},\cdots ,w_{1N}\right),w_{1i}=\frac{1}{N},i=1,2,\cdots ,N$
(2) 对于m=1,2,…,M

• 使用具有权值分布$D_m$的训练数据集进行学习，得到基本分类器： G m ( x ) : X → { − 1 , + 1 } G_{m}(x): \mathcal{X} \rightarrow\{-1,+1\} Gm​(x):X→{−1,+1}
• 计算$G_m(x)$在训练集上的分类误差率$e_m={\sum }_{i=1}^{N}P\left(G_m\left(x_i\right)\ne y_i\right)={\sum }_{i=1}^N{w}_{mi}I\left(G_m\left(x_i\right)\ne y_i\right)$
• 计算$G_m(x)$的系数${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$，这里的log是自然对数ln
• 更新训练数据集的权重分布
  $$\begin{array}{c}{D}_{m+1}=\left(w_{m+1,1},\cdots ,w_{m+1,i},\cdots ,w_{m+1,N}\right)\\ w_{m+1,i}=\frac{w_{mi}}{Z_m}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right),i=1,2,\cdots ,N\end{array}$$
  这里的$Z_m$是规范化因子，使得$D_{m+1}$称为概率分布，$Z_m={\sum }_{i=1}^N{w}_{mi}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right)$

(3) 构建基本分类器的线性组合$f(x)={\sum }_{m=1}^M{\alpha }_m{G}_m(x)$，得到最终的分类器

$$\begin{array}{rl}G(x)& =\mathrm{sign}(f(x))\\ & =\mathrm{sign}\left(\sum _{m=1}^M{\alpha }_m{G}_m(x)\right)\end{array}$$

Adaboost步骤说明

(1) 初始化训练数据分布权重，假设训练连数据的权值分布是均匀的，使没有先验信息的条件下每个样本在基本分类器的学习中作用一样；
(2) 每一次迭代在基本的分类器上修正分类的错误率，错误分类的样本权重被扩大。
(3) 线性组合 $f(x)$ 将M个基本分类器加权表决。

通过sklearn对Adaboost算法进行建模

案例为UCI的机器学习库开源数据集：葡萄酒数据集，包含178个样本和13个特征。

# 引入数据科学相关工具包：
import numpy as np
import pandas as pd 

import matplotlib.pyplot as plt
import seaborn as sns

plt.style.use("ggplot")
%matplotlib inline

# 加载训练数据：         
wine = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data",header=None)
wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols','Flavanoids', 'Nonflavanoid phenols', 
                'Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline']

# 数据分析
import pandas_profiling as pp

report = pp.ProfileReport(wine)
report

# 数据预处理
# 仅仅考虑2，3类葡萄酒，去除1类
wine = wine[wine['Class label'] != 1]
y = wine['Class label'].values
X = wine[['Alcohol','OD280/OD315 of diluted wines']].values

# 将分类标签变成二进制编码：
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y = le.fit_transform(y)

# 按8：2分割训练集和测试集
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)  # stratify参数代表了按照y的类别等比例抽样

# 使用单一决策树建模
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

tree = DecisionTreeClassifier(criterion='entropy',random_state=1,max_depth=1)
tree = tree.fit(X_train,y_train)

y_train_pred = tree.predict(X_train)
y_test_pred = tree.predict(X_test)
tree_train = accuracy_score(y_train,y_train_pred)
tree_test = accuracy_score(y_test,y_test_pred)

print('Decision tree train/test accuracies %.3f/%.3f' % (tree_train,tree_test))

Decision tree train/test accuracies 0.916/0.875

from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(base_estimator=tree,n_estimators=500,learning_rate=0.1,random_state=1)
ada = ada.fit(X_train,y_train)

y_train_pred = ada.predict(X_train)
y_test_pred = ada.predict(X_test)
ada_train = accuracy_score(y_train,y_train_pred)
ada_test = accuracy_score(y_test,y_test_pred)

print('Adaboost train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

Adaboost train/test accuracies 1.000/0.917

# 使用sklearn实现Adaboost(基分类器为决策树)
'''
AdaBoostClassifier相关参数：
base_estimator：基本分类器，默认为DecisionTreeClassifier(max_depth=1)
n_estimators：终止迭代的次数
learning_rate：学习率
algorithm：训练的相关算法，{'SAMME'，'SAMME.R'}，默认='SAMME.R'
random_state：随机种子
'''

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import zero_one_loss
from sklearn.ensemble import AdaBoostClassifier

n_estimators = 200
# A learning rate of 1. may not be optimal for both SAMME and SAMME.R
learning_rate = 1.

dt_stump = DecisionTreeClassifier(max_depth=1, min_samples_leaf=1)
dt_stump.fit(X_train, y_train)
dt_stump_err = 1.0 - dt_stump.score(X_test, y_test)

dt = DecisionTreeClassifier(max_depth=9, min_samples_leaf=1)
dt.fit(X_train, y_train)
dt_err = 1.0 - dt.score(X_test, y_test)

ada_discrete = AdaBoostClassifier(
    base_estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME")
ada_discrete.fit(X_train, y_train)

y_train_pred = ada.predict(X_train)
y_test_pred = ada.predict(X_test)
ada_train = accuracy_score(y_train,y_train_pred)
ada_test = accuracy_score(y_test,y_test_pred)
print('Adaboost SAMME train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

ada_real = AdaBoostClassifier(
    base_estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME.R")
ada_real.fit(X_train, y_train)

y_train_pred = ada.predict(X_train)
y_test_pred = ada.predict(X_test)
ada_train = accuracy_score(y_train,y_train_pred)
ada_test = accuracy_score(y_test,y_test_pred)
print('Adaboost SAMME.R train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

fig = plt.figure()
ax = fig.add_subplot(111)

ax.plot([1, n_estimators], [dt_stump_err] * 2, 'k-',
        label='Decision Stump Error')
ax.plot([1, n_estimators], [dt_err] * 2, 'k--',
        label='Decision Tree Error')

ada_discrete_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_test)):
    ada_discrete_err[i] = zero_one_loss(y_pred, y_test)

ada_discrete_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_train)):
    ada_discrete_err_train[i] = zero_one_loss(y_pred, y_train)

ada_real_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_test)):
    ada_real_err[i] = zero_one_loss(y_pred, y_test)

ada_real_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_train)):
    ada_real_err_train[i] = zero_one_loss(y_pred, y_train)

ax.plot(np.arange(n_estimators) + 1, ada_discrete_err,
        label='Discrete AdaBoost Test Error',
        color='red')
ax.plot(np.arange(n_estimators) + 1, ada_discrete_err_train,
        label='Discrete AdaBoost Train Error',
        color='blue')
ax.plot(np.arange(n_estimators) + 1, ada_real_err,
        label='Real AdaBoost Test Error',
        color='orange')
ax.plot(np.arange(n_estimators) + 1, ada_real_err_train,
        label='Real AdaBoost Train Error',
        color='green')

ax.set_ylim((0.0, 0.2))
ax.set_xlabel('n_estimators')
ax.set_ylabel('error rate')

leg = ax.legend(loc='upper right', fancybox=True)
leg.get_frame().set_alpha(0.7)

plt.show()

Adaboost SAMME train/test accuracies 1.000/0.917
Adaboost SAMME.R train/test accuracies 1.000/0.917

单层决策树对训练数据欠拟合，Adaboost模型能够更准确地训练模型，但通过降低偏差提升准确率的方法会造成一定程度的过拟合。

# 画出单层决策树与Adaboost的决策边界：
x_min = X_train[:, 0].min() - 1
x_max = X_train[:, 0].max() + 1
y_min = X_train[:, 1].min() - 1
y_max = X_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))
f, axarr = plt.subplots(nrows=1, ncols=2,sharex='col',sharey='row',figsize=(12, 6))
for idx, clf, tt in zip([0, 1],[tree, ada_real],['Decision tree', 'Adaboost']):
    clf.fit(X_train, y_train)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    axarr[idx].contourf(xx, yy, Z, alpha=0.3)
    axarr[idx].scatter(X_train[y_train==0, 0],X_train[y_train==0, 1],c='blue', marker='^')
    axarr[idx].scatter(X_train[y_train==1, 0],X_train[y_train==1, 1],c='red', marker='o')
    axarr[idx].set_title(tt)
axarr[0].set_ylabel('Alcohol', fontsize=12)
plt.tight_layout()
plt.text(0, -0.2,s='OD280/OD315 of diluted wines',ha='center',va='center',fontsize=12,transform=axarr[1].transAxes)
plt.show()

3. 前向分布算法

回看Adaboost的算法内容，我们需要通过计算M个基本分类器，每个分类器的错误率、样本权重以及模型权重。我们可以认为：Adaboost每次学习单一分类器以及单一分类器的参数(权重)。接下来，我们抽象出Adaboost算法的整体框架逻辑，构建集成学习的一个非常重要的框架----前向分步算法，有了这个框架，我们不仅可以解决分类问题，也可以解决回归问题。
(1) 加法模型：
在Adaboost模型中，我们把每个基本分类器合成一个复杂分类器的方法是每个基本分类器的加权和，即：$f(x)={\sum }_{m=1}^M{\beta }_{m}b\left(x;{\gamma }_m\right)$，其中，$b\left(x;{\gamma }_m\right)$为即基本分类器，${\gamma }_m$为基本分类器的参数，${\beta }_m$为基本分类器的权重，显然这与第二章所学的加法模型。为什么这么说呢？大家把$b(x;{\gamma }_m)$看成是即函数即可。
在给定训练数据以及损失函数$L(y,f(x))$的条件下，学习加法模型$f(x)$就是：
$$\underset{{\beta }_m,{\gamma }_m}{\min }\sum _{i=1}^{N}L\left(y_i,\sum _{m=1}^M{\beta }_{m}b\left(x_i;{\gamma }_m\right)\right)$$
通常这是一个复杂的优化问题，很难通过简单的凸优化的相关知识进行解决。前向分步算法可以用来求解这种方式的问题，它的基本思路是：因为学习的是加法模型，如果从前向后，每一步只优化一个基函数及其系数，逐步逼近目标函数，那么就可以降低优化的复杂度。具体而言，每一步只需要优化：
$$\underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L\left(y_i,\beta b\left(x_i;\gamma \right)\right)$$
(2) 前向分步算法：
给定数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}，$x_i\in \mathcal{X}\subseteq {\mathbf{R}}^n$， y i ∈ Y = { + 1 , − 1 } y_{i} \in \mathcal{Y}=\{+1,-1\} yi​∈Y={+1,−1}。损失函数$L(y,f(x))$，基函数集合 { b ( x ; γ ) } \{b(x ; \gamma)\} {b(x;γ)}，我们需要输出加法模型$f(x)$。

• 初始化：$f_0(x)=0$
• 对m = 1,2,…,M:
  • (a) 极小化损失函数：
    $$\left({\beta }_m,{\gamma }_m\right)=\arg \underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L\left(y_i,f_{m-1}\left(x_i\right)+\beta b\left(x_i;\gamma \right)\right)$$
    得到参数${\beta }_m$与${\gamma }_m$
  • (b) 更新：
    $$f_m(x)=f_{m-1}(x)+{\beta }_{m}b\left(x;{\gamma }_m\right)$$
• 得到加法模型：
  $$f(x)=f_M(x)=\sum _{m=1}^M{\beta }_{m}b\left(x;{\gamma }_m\right)$$

这样，前向分步算法将同时求解从m=1到M的所有参数${\beta }_m$，${\gamma }_m$的优化问题简化为逐次求解各个${\beta }_m$，${\gamma }_m$的问题。
(3) 前向分步算法与Adaboost的关系：
由于这里不是我们的重点，我们主要阐述这里的结论，不做相关证明，具体的证明见李航老师的《统计学习方法》第八章的3.2节。Adaboost算法是前向分步算法的特例，Adaboost算法是由基本分类器组成的加法模型，损失函数为指数损失函数。

4. 梯度提升决策树（GBDT）

(1) 基于残差学习的提升树算法

树模型最重要的是寻找到最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。

回忆Boosting算法中两个核心问题：

• 提高被分类器错误分类样本的权重，降低正确分类样本权重；
• 各个弱分类器的组合通过采取加权多数表决的方式；

使用假发模型+前向分布算法的框架实现回归问题：

• 问题：使用熵之类的指标不再适用于评判连续误差，Adaboost算法使用分类错误率修正样本权重；
• 解决方法：采用平方差评判拟合程度，并利用每个样本的残差表示每次使用基函数预测没有解决的问题；

因此，我们可以得出如下算法：
输入数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } , x i ∈ X ⊆ R n , y i ∈ Y ⊆ R T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\}, x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y_{i} \in \mathcal{Y} \subseteq \mathbf{R} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)},xi​∈X⊆Rn,yi​∈Y⊆R，输出最终的提升树$f_M(x)$

• 初始化$f_0(x)=0$
• 对m = 1,2,…,M：
  • 计算每个样本的残差:$r_{mi}=y_i-f_{m-1}\left(x_i\right),i=1,2,\cdots ,N$
  • 拟合残差$r_{mi}$学习一棵回归树，得到$T\left(x;{\Theta }_m\right)$
  • 更新$f_m(x)=f_{m-1}(x)+T\left(x;{\Theta }_m\right)$
• 得到最终的回归问题的提升树：$f_M(x)={\sum }_{m=1}^{M}T\left(x;{\Theta }_m\right)$

举例参考李航老师《统计学习方法》第八章。
至此，我们已经能够建立起依靠加法模型+前向分步算法的框架解决回归问题的算法，叫提升树算法，而下面讲的GBDT将假发提升树做出一定优化。

(2) 梯度提升决策树（GBDT）

对比以下损失函数：
 Setting   Loss Function  − ∂ L ( y i , f ( x i ) ) / ∂ f ( x i )  Regression  1 2 [ y i − f ( x i ) ] 2 y i − f ( x i )  Regression  ∣ y i − f ( x i ) ∣ sign ⁡ [ y i − f ( x i ) ]  Regression   Huber  y i − f ( x i )  for  ∣ y i − f ( x i ) ∣ ≤ δ m δ m sign ⁡ [ y i − f ( x i ) ]  for  ∣ y i − f ( x i ) ∣ > δ m  where  δ m = α  th-quantile  { ∣ y i − f ( x i ) ∣ }  Classification   Deviance  k  th component:  I ( y i = G k ) − p k ( x i ) \begin{array}{l|l|l} \hline \text { Setting } & \text { Loss Function } & -\partial L\left(y_{i}, f\left(x_{i}\right)\right) / \partial f\left(x_{i}\right) \\ \hline \text { Regression } & \frac{1}{2}\left[y_{i}-f\left(x_{i}\right)\right]^{2} & y_{i}-f\left(x_{i}\right) \\ \hline \text { Regression } & \left|y_{i}-f\left(x_{i}\right)\right| & \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \\ \hline \text { Regression } & \text { Huber } & y_{i}-f\left(x_{i}\right) \text { for }\left|y_{i}-f\left(x_{i}\right)\right| \leq \delta_{m} \\ & & \delta_{m} \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \text { for }\left|y_{i}-f\left(x_{i}\right)\right|>\delta_{m} \\ & & \text { where } \delta_{m}=\alpha \text { th-quantile }\left\{\left|y_{i}-f\left(x_{i}\right)\right|\right\} \\ \hline \text { Classification } & \text { Deviance } & k \text { th component: } I\left(y_{i}=\mathcal{G}_{k}\right)-p_{k}\left(x_{i}\right) \\ \hline \end{array}  Setting  Regression  Regression  Regression  Classification ​ Loss Function 21​[yi​−f(xi​)]2∣yi​−f(xi​)∣ Huber  Deviance ​−∂L(yi​,f(xi​))/∂f(xi​)yi​−f(xi​)sign[yi​−f(xi​)]yi​−f(xi​) for ∣yi​−f(xi​)∣≤δm​δm​sign[yi​−f(xi​)] for ∣yi​−f(xi​)∣>δm​ where δm​=α th-quantile {∣yi​−f(xi​)∣}k th component: I(yi​=Gk​)−pk​(xi​)​​
观察Huber损失函数：
$$L_{\delta }(y,f(x))=\{\begin{array}{ll}\frac{1}{2}(y-f(x){)}^2& \text{ for }|y-f(x)|\le \delta \\ \delta |y-f(x)|-\frac{1}{2}{\delta }^2& \text{ otherwise }\end{array}$$
针对上面的问题，Freidman提出了梯度提升算法(gradient boosting)，这是利用最速下降法的近似方法，利用损失函数的负梯度在当前模型的值$-{\left[\frac{\partial L\left(y,f\left(x_i\right)\right)}{\partial f\left(x_i\right)}\right]}_{f(x)=f_{m-1}(x)}$作为回归问题提升树算法中的残差的近似值，拟合回归树。与其说负梯度作为残差的近似值，不如说残差是负梯度的一种特例。

以下开始具体介绍梯度提升算法：
输入训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } , x i ∈ X ⊆ R n , y i ∈ Y ⊆ R T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\}, x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y_{i} \in \mathcal{Y} \subseteq \mathbf{R} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)},xi​∈X⊆Rn,yi​∈Y⊆R和损失函数$L(y,f(x))$，输出回归树$\hat{f}(x)$

• 初始化$f_0(x)=\arg {\min }_c{\sum }_{i=1}^{N}L\left(y_i,c\right)$
• 对于m=1,2,…,M：
  • 对i = 1,2,…,N计算：$r_{mi}=-{\left[\frac{\partial L\left(y_i,f\left(x_i\right)\right)}{\partial f\left(x_i\right)}\right]}_{f(x)=f_{m-1}(x)}$
  • 对$r_{mi}$拟合一个回归树，得到第m棵树的叶结点区域$R_{mj},j=1,2,\cdots ,J$
  • 对j=1,2,…J，计算：$c_{mj}=\arg {\min }_c{\sum }_{x_i\in R_{mj}}L\left(y_i,f_{m-1}\left(x_i\right)+c\right)$
  • 更新$f_m(x)=f_{m-1}(x)+{\sum }_{j=1}^J{c}_{mj}I\left(x\in R_{mj}\right)$
• 得到回归树：$\hat{f}(x)=f_M(x)={\sum }_{m=1}^M{\sum }_{j=1}^J{c}_{mj}I\left(x\in R_{mj}\right)$

案例解释说明GBDT如何运作的。
sklearn中GBDT回归的使用
sklearn中GBDT分类的使用

GradientBoostingRegressor参数解释：

• loss：{‘ls’, ‘lad’, ‘huber’, ‘quantile’}, default=’ls’：‘ls’ 指最小二乘回归. ‘lad’ (最小绝对偏差) 是仅基于输入变量的顺序信息的高度鲁棒的损失函数。. ‘huber’ 是两者的结合. ‘quantile’允许分位数回归（用于alpha指定分位数）

• learning_rate：学习率缩小了每棵树的贡献learning_rate。在learning_rate和n_estimators之间需要权衡。

• n_estimators：要执行的提升次数。

• subsample：用于拟合各个基础学习者的样本比例。如果小于1.0，则将导致随机梯度增强。subsample与参数 - n_estimators。选择会导致方差减少和偏差增加。subsample < 1.0

• criterion：{‘friedman_mse’，‘mse’，‘mae’}，默认=‘friedman_mse’：“ mse”是均方误差，“ mae”是平均绝对误差。默认值“ friedman_mse”通常是最好的，因为在某些情况下它可以提供更好的近似值。

• min_samples_split：拆分内部节点所需的最少样本数

• min_samples_leaf：在叶节点处需要的最小样本数。

• min_weight_fraction_leaf：在所有叶节点处（所有输入样本）的权重总和中的最小加权分数。如果未提供sample_weight，则样本的权重相等。

• max_depth：各个回归模型的最大深度。最大深度限制了树中节点的数量。调整此参数以获得最佳性能；最佳值取决于输入变量的相互作用。

• min_impurity_decrease：如果节点分裂会导致杂质的减少大于或等于该值，则该节点将被分裂。

• min_impurity_split：提前停止树木生长的阈值。如果节点的杂质高于阈值，则该节点将分裂

• max_features{‘auto’, ‘sqrt’, ‘log2’}，int或float：寻找最佳分割时要考虑的功能数量：

  • 如果为int，则max_features在每个分割处考虑特征。

  • 如果为float，max_features则为小数，并 在每次拆分时考虑要素。int(max_features * n_features)

  • 如果“auto”，则max_features=n_features。

  • 如果是“ sqrt”，则max_features=sqrt(n_features)。

  • 如果为“ log2”，则为max_features=log2(n_features)。

  • 如果没有，则max_features=n_features。

GradientBoostingClassifier参数解释：

• loss{‘ls’, ‘lad’, ‘huber’, ‘quantile’}, default=’ls’ ‎损失函数优化方法。‘ls’ 指最小二乘回归. ‘lad’ (最小绝对偏差) 是仅基于输入变量的顺序信息的高度鲁棒的损失函数。. ‘huber’ 是两者的结合. ‘quantile’允许分位数回归（用于alpha指定分位数）
• learning_ratefloat, default=0.1，学习率会使每棵树的贡献缩小。learning_rate和n_estimators之间有一个权衡。
• n_estimatorsint, default=100，要执行的提升阶段的数量。梯度提升是相当稳健的过度拟合，所以大量的通常会导致更好的性能。
• subsamplefloat, default=1.0，用于拟合各个基础学习者的样本比例。 如果小于1.0，则将导致随机梯度增强。 与参数交互。 选择会导致方差减少和偏差增加。
• criterion{‘friedman_mse’, ‘mse’, ‘mae’}, default=’friedman_mse’，‎测量拆分质量的功能。支持的标准是"friedman_mse"的平均平方错误与改进分数由弗里德曼，"mse"的平均平方错误，和"mae"的平均绝对错误。"friedman_mse"的默认值通常是最好的，因为它在某些情况下可以提供更好的近似值。‎
• min_samples_splitint or float, default=2，拆分内部节点所需的最少样本数。
• min_samples_leafint or float, default=1，在叶节点处需要的最小样本数。 仅在任何深度的分割点在左分支和右分支中的每个分支上至少留下min_samples_leaf个训练样本时，才考虑该点。 这可能具有平滑模型的效果，尤其是在回归中。
• min_weight_fraction_leaffloat, default=0.0，‎在叶节点所需的重量总和（所有输入样本中）的最小加权分数。当未提供sample_weight时，样品的重量相等。‎
• max_depthint, default=3，‎单个回归估计器的最大深度。最大深度限制树中的节点数。调整此参数以获得最佳性能;最佳值取决于输入变量的交互性。‎
• min_impurity_decreasefloat, default=0.0，‎如果这种分裂导致杂质大于或等于此值的减少，则节点将被分割。‎
• min_impurity_splitfloat, default=None，‎树生长早期停止的阈值。如果节点的杂质高于阈值，则节点将分裂，否则它是一片叶子。‎
• initestimator or ‘zero’, default=None，‎用于计算初始预测的估计对象。‎
• random_stateint, RandomState instance or None, default=None，‎控制每个树估计器在每个增强迭代中给每个树估计器的随机种子。此外，它还控制每个拆分处功能的随机排列（有关详细信息，请参阅注释）。‎
• max_features{‘auto’, ‘sqrt’, ‘log2’}, int or float, default=None，‎查找最佳拆分时要考虑的功能数量。
• alphafloat, default=0.9， huber loss 和 quantile loss 的函数参数。
• verboseint, default=0，启用详细输出。 如果为1，则偶尔打印一次进度和性能（树越多，频率越低）。 如果大于1，则将打印每棵树的进度和性能。
• max_leaf_nodesint, default=None，以最佳优先方式种植具有max_leaf_nodes的树。 最佳节点定义为杂质的相对减少。 如果为None，则叶节点数不受限制。
• warm_startbool, default=False，设置为True时，请重用上一个调用的解决方案以适应并在集合中添加更多的估计量，否则，只需擦除以前的解决方案即可。
• validation_fractionfloat, default=0.1，预留的训练数据比例作为早期停止的验证集，必须介于0和1之间。当 ** n_iter_no_change ** 设置为整数时有效。
• n_iter_no_changeint, default=None，用于确定在验证分数没有改善时是否将使用早期停止来终止训练。
• tolfloat, default=1e-4，用于停止预训练。
• ccp_alphanon-negative float, default=0.0，用于最小化成本复杂性修剪的复杂性参数。

from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_friedman1
from sklearn.ensemble import GradientBoostingRegressor

X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0)
X_train, X_test = X[:1000], X[1000:]
y_train, y_test = y[:1000], y[1000:]
est = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1,
    max_depth=1, random_state=0, loss='ls').fit(X_train, y_train)
mean_squared_error(y_test, est.predict(X_test))

输出为：3.970430114429308

from sklearn.datasets import make_regression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split

X, y = make_regression(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, random_state=0)
reg = GradientBoostingRegressor(random_state=0)
reg.fit(X_train, y_train)
reg.score(X_test, y_test)

输出为：0.43251288877169414

5. XGBoost算法

Xgboost算法原理

XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。

Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：
引用陈天奇的论文，我们的数据为： D = { ( x i , y i ) } ( ∣ D ∣ = n , x i ∈ R m , y i ∈ R ) \mathcal{D}=\left\{\left(\mathbf{x}_{i}, y_{i}\right)\right\}\left(|\mathcal{D}|=n, \mathbf{x}_{i} \in \mathbb{R}^{m}, y_{i} \in \mathbb{R}\right) D={(xi​,yi​)}(∣D∣=n,xi​∈Rm,yi​∈R)
(1) 构造目标函数：
假设有K棵树，则第i个样本的输出为${\hat{y}}_i=\varphi \left({\mathrm{x}}_i\right)={\sum }_{k=1}^K{f}_k\left({\mathrm{x}}_i\right),f_k\in \mathcal{F}$，其中，$\mathcal{F}=\left\{f(\mathbf{x})=w_{q(\mathbf{x})}\right\}\left(q:{\mathbb{R}}^m\to T,w\in {\mathbb{R}}^T\right)$
因此，目标函数的构建为：
$$\mathcal{L}(\varphi )=\sum _{i}l\left({\hat{y}}_i,y_i\right)+\sum _k\Omega \left(f_k\right)$$
其中，${\sum }_{i}l\left({\hat{y}}_i,y_i\right)$为loss function，${\sum }_k\Omega \left(f_k\right)$为正则化项。
(2) 叠加式的训练(Additive Training)：
给定样本$x_i$，${\hat{y}}_i^{(0)}=0$(初始预测)，${\hat{y}}_i^{(1)}={\hat{y}}_i^{(0)}+f_1(x_i)$，${\hat{y}}_i^{(2)}={\hat{y}}_i^{(0)}+f_1(x_i)+f_2(x_i)={\hat{y}}_i^{(1)}+f_2(x_i)$…以此类推，可以得到：$ \hat{y}_i^{(K)} = \hat{y}_i^{(K-1)} + f_K(x_i)$ ，其中，$ \hat{y}_i^{(K-1)} $ 为前K-1棵树的预测结果，$ f_K(x_i)$ 为第K棵树的预测结果。
因此，目标函数可以分解为：
$${\mathcal{L}}^{(K)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+\sum _k\Omega \left(f_k\right)$$
由于正则化项也可以分解为前K-1棵树的复杂度加第K棵树的复杂度，因此：${\mathcal{L}}^{(K)}={\sum }_{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+{\sum }_{k=1}^{K-1}\Omega \left(f_k\right)+\Omega \left(f_K\right)$，由于${\sum }_{k=1}^{K-1}\Omega \left(f_k\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
$${\mathcal{L}}^{(K)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+\Omega \left(f_K\right)$$
(3) 使用泰勒级数近似目标函数：
$${\mathcal{L}}^{(K)}\simeq \sum _{i=1}^n\left[l\left(y_i,{\hat{y}}^{(K-1)}\right)+g_i{f}_K\left({\mathrm{x}}_i\right)+\frac{1}{2}{h}_i{f}_K^2\left({\mathrm{x}}_i\right)\right]+\Omega \left(f_K\right)$$
其中，$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)$
在这里，我们补充下泰勒级数的相关知识：
在数学中，泰勒级数（英语：Taylor series）用无限项连加式——级数来表示一个函数，这些相加的项由函数在某一点的导数求得。具体的形式如下：
$$f(x)=\frac{f\left(x_0\right)}{0!}+\frac{f^{\prime }\left(x_0\right)}{1!}\left(x-x_0\right)+\frac{f^{\prime \prime }\left(x_0\right)}{2!}{\left(x-x_0\right)}^2+\dots +\frac{f^{(n)}\left(x_0\right)}{n!}{\left(x-x_0\right)}^n+......$$
由于${\sum }_{i=1}^{n}l\left(y_i,{\hat{y}}^{(K-1)}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
$${\tilde{\mathcal{L}}}^{(K)}=\sum _{i=1}^n\left[g_i{f}_K\left({\mathbf{x}}_i\right)+\frac{1}{2}{h}_i{f}_K^2\left({\mathbf{x}}_i\right)\right]+\Omega \left(f_K\right)$$
(4) 如何定义一棵树：
为了说明如何定义一棵树的问题，我们需要定义几个概念：第一个概念是样本所在的节点位置$q(x)$，第二个概念是有哪些样本落在节点j上 I j = { i ∣ q ( x i ) = j } I_{j}=\left\{i \mid q\left(\mathbf{x}_{i}\right)=j\right\} Ij​={i∣q(xi​)=j}，第三个概念是每个结点的预测值$w_{q(x)}$，第四个概念是模型复杂度$\Omega \left(f_K\right)$，它可以由叶子节点的个数以及节点函数值来构建，则：$\Omega \left(f_K\right)=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{w}_j^2$。

$q(x_1)=1,q(x_2)=3,q(x_3)=1,q(x_4)=2,q(x_5)=3$， I 1 = { 1 , 3 } , I 2 = { 4 } , I 3 = { 2 , 5 } I_1 = \{1,3\},I_2 = \{4\},I_3 = \{2,5\} I1​={1,3},I2​={4},I3​={2,5}，$w=(15,12,20)$
因此，目标函数用以上符号替代后：
$$\begin{array}{rl}{\tilde{\mathcal{L}}}^{(K)}& =\sum _{i=1}^n\left[g_i{f}_K\left({\mathrm{x}}_i\right)+\frac{1}{2}{h}_i{f}_K^2\left({\mathrm{x}}_i\right)\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+\lambda \right)w_j^2\right]+\gamma T\end{array}$$
由于我们的目标就是最小化目标函数，现在的目标函数化简为一个关于w的二次函数：${\tilde{\mathcal{L}}}^{(K)}={\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$，根据二次函数求极值的公式：$y=a{x}^{2}bxc$求极值，对称轴在$x=-\frac{b}{2a}$，极值为$y=\frac{4ac-b^2}{4a}$，因此：
$$w_j^{\ast }=-\frac{{\sum }_{i\in I_j}{g}_i}{{\sum }_{i\in I_j}{h}_i+\lambda }$$
以及
$${\tilde{\mathcal{L}}}^{(K)}(q)=-\frac{1}{2}\sum _{j=1}^T\frac{{\left({\sum }_{i\in I_j}{g}_i\right)}^2}{{\sum }_{i\in I_j}{h}_i+\lambda }+\gamma T$$

（5）寻找树的形状

Xgboost算法案例

不难发现，刚刚的讨论都是基于树的形状已经确定了计算$w$和$L$，但是实际上我们需要像学习决策树一样找到树的形状。因此，我们借助决策树学习的方式，使用目标函数的变化来作为分裂节点的标准。我们使用一个例子来说明：

例子中有8个样本，分裂方式如下，因此:
$$\begin{gathered} {\tilde{\mathcal{L}}}^{(old)}=-\frac{1}{2}[\frac{(g_7+g_8{)}^2}{H_7+H_8+\lambda }+\frac{(g_1+...+g_6{)}^2}{H_1+...+H_6+\lambda }]+2\gamma \\ {\tilde{\mathcal{L}}}^{(new)}=-\frac{1}{2}[\frac{(g_7+g_8{)}^2}{H_7+H_8+\lambda }+\frac{(g_1+...+g_3{)}^2}{H_1+...+H_3+\lambda }+\frac{(g_4+...+g_6{)}^2}{H_4+...+H_6+\lambda }]+3\gamma \\ {\tilde{\mathcal{L}}}^{(old)}-{\tilde{\mathcal{L}}}^{(new)}=\frac{1}{2}[\frac{(g_1+...+g_3{)}^2}{H_1+...+H_3+\lambda }+\frac{(g_4+...+g_6{)}^2}{H_4+...+H_6+\lambda }-\frac{(g_1+...+g_6{)}^2}{h_1+...+h_6+\lambda }]-\gamma \end{gathered}$$
因此，从上面的例子看出：分割节点的标准为 m a x { L ~ ( o l d ) − L ~ ( n e w ) } max\{\tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} \} max{L~(old)−L~(new)}，即：
$${\mathcal{L}}_{\text{split }}=\frac{1}{2}\left[\frac{{\left({\sum }_{i\in I_L}{g}_i\right)}^2}{{\sum }_{i\in I_L}{h}_i+\lambda }+\frac{{\left({\sum }_{i\in I_R}{g}_i\right)}^2}{{\sum }_{i\in I_R}{h}_i+\lambda }-\frac{{\left({\sum }_{i\in I}{g}_i\right)}^2}{{\sum }_{i\in I}{h}_i+\lambda }\right]-\gamma$$

（6）树的分裂方法

（6.1）精确贪心分裂算法（按boost算法的分割模式）

XGBoost在生成新树的过程中，最基本的操作是节点分裂。节点分裂中最重要的环节是找到最优特征及最优切分点, 然后将叶子节点按照最优特征和最优切分点进行分裂。选取最优特征和最优切分点的一种思路如下：首先找到所有的候 选特征及所有的候选切分点, 一一求得其 ${\mathcal{L}}_{\text{split }}$, 然后选择${\mathcal{L}}_{\mathrm{s}\mathrm{p}\mathrm{l}\mathrm{i}\mathrm{t}}$ 最大的特征及 对应切分点作为最优特征和最优切分点。我们称此种方法为精确贪心算法。该算法是一种启发式算法, 因为在节点分裂时只选择当前最优的分裂策略, 而非全局最优的分裂策略。

（6.2）基于直方图的近似算法（）

精确贪心算法在选择最优特征和最优切分点时是一种十分有效的方法。它计算了所有特征、所有切分点的收益, 并从中选择了最优的, 从而保证模型能比较好地拟合了训练数据。但是当数据不能完全加载到内存时，精确贪心算法会变得 非常低效，算法在计算过程中需要不断在内存与磁盘之间进行数据交换，这是个非常耗时的过程, 并且在分布式环境中面临同样的问题。为了能够更高效地选 择最优特征及切分点, XGBoost提出一种近似算法来解决该问题。 基于直方图的近似算法的主要思想是：对某一特征寻找最优切分点时，首先对该特征的所有切分点按分位数 (如百分位) 分桶, 得到一个候选切分点集。特征的每一个切分点都可以分到对应的分桶; 然后，对每个桶计算特征统计G和H得到直方图, G为该桶内所有样本一阶特征统计g之和, H为该桶内所有样本二阶特征统计h之和; 最后，选择所有候选特征及候选切分点中对应桶的特征统计收益最大的作为最优特征及最优切分点。基于直方图的近似算法的计算过程如下所示：

1. 对于每个特征 $k=1,2,\cdots ,m,$ 按分位数对特征 $k$ 分桶 $\Theta ,$ 可得候选切分点, S k = { S k 1 , S k 2 , ⋯   , S k l } 1 S_{k}=\left\{S_{k 1}, S_{k 2}, \cdots, S_{k l}\right\}^{1} Sk​={Sk1​,Sk2​,⋯,Skl​}1
2. 对于每个特征 $k=1,2,\cdots ,m,$ 有：
   G k v ← = ∑ j ∈ { j ∣ s k , v ≥ x j k > s k , v − 1    } g j H k v ← = ∑ j ∈ { j ∣ s k , v ≥ x j k > s k , v − 1    } h j \begin{array}{l} G_{k v} \leftarrow=\sum_{j \in\left\{j \mid s_{k, v} \geq \mathbf{x}_{j k}>s_{k, v-1\;}\right\}} g_{j} \\ H_{k v} \leftarrow=\sum_{j \in\left\{j \mid s_{k, v} \geq \mathbf{x}_{j k}>s_{k, v-1\;}\right\}} h_{j} \end{array} Gkv​←=∑j∈{j∣sk,v​≥xjk​>sk,v−1​}​gj​Hkv​←=∑j∈{j∣sk,v​≥xjk​>sk,v−1​}​hj​​
3. 类似精确贪心算法，依据梯度统计找到最大增益的候选切分点。
   下面用一个例子说明基于直方图的近似算法：
   假设有一个年龄特征，其特征的取值为18、19、21、31、36、37、55、57，我们需要使用近似算法找到年龄这个特征的最佳分裂点：

近似算法实现了两种候选切分点的构建策略：全局策略和本地策略。全局策略是在树构建的初始阶段对每一个特征确定一个候选切分点的集合, 并在该树每一层的节点分裂中均采用此集合计算收益, 整个过程候选切分点集合不改变。本地策略则是在每一次节点分裂时均重新确定候选切分点。全局策略需要更细的分桶才能达到本地策略的精确度, 但全局策略在选取候选切分点集合时比本地策略更简单。在XGBoost系统中, 用户可以根据需求自由选择使用精确贪心算法、近似算法全局策略、近似算法本地策略, 算法均可通过参数进行配置。

XGBoost的参数设置(括号内的名称为sklearn接口对应的参数名字):
推荐博客：https://link.zhihu.com/?target=https%3A//blog.youkuaiyun.com/luanpeng825485697/article/details/79907149
推荐官方文档：https://link.zhihu.com/?target=https%3A//xgboost.readthedocs.io/en/latest/parameter.html

XGBoost的参数分为三种：

• 通用参数：（两种类型的booster，因为tree的性能比线性回归好得多，因此我们很少用线性回归。）

  • booster:使用哪个弱学习器训练，默认gbtree，可选gbtree，gblinear 或dart
  • nthread：用于运行XGBoost的并行线程数，默认为最大可用线程数
  • verbosity：打印消息的详细程度。有效值为0（静默），1（警告），2（信息），3（调试）。
  • Tree Booster的参数：
    • eta（learning_rate）：learning_rate，在更新中使用步长收缩以防止过度拟合，默认= 0.3，范围：[0,1]；典型值一般设置为：0.01-0.2
    • gamma（min_split_loss）：默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。范围：[0，∞]
    • max_depth：默认= 6，一棵树的最大深度。增加此值将使模型更复杂，并且更可能过度拟合。范围：[0，∞]
    • min_child_weight：默认值= 1，如果新分裂的节点的样本权重和小于min_child_weight则停止分裂 。这个可以用来减少过拟合，但是也不能太高，会导致欠拟合。范围：[0，∞]
    • max_delta_step：默认= 0，允许每个叶子输出的最大增量步长。如果将该值设置为0，则表示没有约束。如果将其设置为正值，则可以帮助使更新步骤更加保守。通常不需要此参数，但是当类极度不平衡时，它可能有助于逻辑回归。将其设置为1-10的值可能有助于控制更新。范围：[0，∞]
    • subsample：默认值= 1，构建每棵树对样本的采样率，如果设置成0.5，XGBoost会随机选择一半的样本作为训练集。范围：（0,1]
    • sampling_method：默认= uniform，用于对训练实例进行采样的方法。
      • uniform：每个训练实例的选择概率均等。通常将subsample> = 0.5 设置 为良好的效果。
      • gradient_based：每个训练实例的选择概率与规则化的梯度绝对值成正比，具体来说就是$\sqrt{g^2+\lambda h^2}$，subsample可以设置为低至0.1，而不会损失模型精度。
    • colsample_bytree：默认= 1，列采样率，也就是特征采样率。范围为（0，1]
    • lambda（reg_lambda）：默认=1，L2正则化权重项。增加此值将使模型更加保守。
    • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。
    • tree_method：默认=auto，XGBoost中使用的树构建算法。
      • auto：使用启发式选择最快的方法。
        • 对于小型数据集，exact将使用精确贪婪（）。
        • 对于较大的数据集，approx将选择近似算法（）。它建议尝试hist，gpu_hist，用大量的数据可能更高的性能。（gpu_hist）支持。external memory外部存储器。
      • exact：精确的贪婪算法。枚举所有拆分的候选点。
      • approx：使用分位数和梯度直方图的近似贪婪算法。
      • hist：更快的直方图优化的近似贪婪算法。（LightGBM也是使用直方图算法）
      • gpu_hist：GPU hist算法的实现。
    • scale_pos_weight:控制正负权重的平衡，这对于不平衡的类别很有用。Kaggle竞赛一般设置sum(negative instances) / sum(positive instances)，在类别高度不平衡的情况下，将参数设置大于0，可以加快收敛。
    • num_parallel_tree：默认=1，每次迭代期间构造的并行树的数量。此选项用于支持增强型随机森林。
    • monotone_constraints：可变单调性的约束，在某些情况下，如果有非常强烈的先验信念认为真实的关系具有一定的质量，则可以使用约束条件来提高模型的预测性能。（例如params_constrained[‘monotone_constraints’] = “(1,-1)”，(1,-1)我们告诉XGBoost对第一个预测变量施加增加的约束，对第二个预测变量施加减小的约束。）
  • Linear Booster的参数：
    • lambda（reg_lambda）：默认= 0，L2正则化权重项。增加此值将使模型更加保守。归一化为训练示例数。
    • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。归一化为训练示例数。
    • updater：默认= shotgun。
      • shotgun：基于shotgun算法的平行坐标下降算法。使用“ hogwild”并行性，因此每次运行都产生不确定的解决方案。
      • coord_descent：普通坐标下降算法。同样是多线程的，但仍会产生确定性的解决方案。
    • feature_selector：默认= cyclic。特征选择和排序方法
      • cyclic：通过每次循环一个特征来实现的。
      • shuffle：类似于cyclic，但是在每次更新之前都有随机的特征变换。
      • random：一个随机(有放回)特征选择器。
      • greedy：选择梯度最大的特征。（贪婪选择）
      • thrifty：近似贪婪特征选择（近似于greedy）
    • top_k：要选择的最重要特征数（在greedy和thrifty内）

• 任务参数（这个参数用来控制理想的优化目标和每一步结果的度量方法。）

  • objective：默认=reg:squarederror，表示最小平方误差。
    • reg:squarederror,最小平方误差。
    • reg:squaredlogerror,对数平方损失。$\frac{1}{2}[log(pred+1)-log(label+1){]}^2$
    • reg:logistic,逻辑回归
    • reg:pseudohubererror,使用伪Huber损失进行回归，这是绝对损失的两倍可微选择。
    • binary:logistic,二元分类的逻辑回归，输出概率。
    • binary:logitraw：用于二进制分类的逻辑回归，逻辑转换之前的输出得分。
    • binary:hinge：二进制分类的铰链损失。这使预测为0或1，而不是产生概率。（SVM就是铰链损失函数）
    • count:poisson –计数数据的泊松回归，泊松分布的输出平均值。
    • survival:cox：针对正确的生存时间数据进行Cox回归（负值被视为正确的生存时间）。
    • survival:aft：用于检查生存时间数据的加速故障时间模型。
    • aft_loss_distribution：survival:aft和aft-nloglik度量标准使用的概率密度函数。
    • multi:softmax：设置XGBoost以使用softmax目标进行多类分类，还需要设置num_class（类数）
    • multi:softprob：与softmax相同，但输出向量，可以进一步重整为矩阵。结果包含属于每个类别的每个数据点的预测概率。
    • rank:pairwise：使用LambdaMART进行成对排名，从而使成对损失最小化。
    • rank:ndcg：使用LambdaMART进行列表式排名，使标准化折让累积收益（NDCG）最大化。
    • rank:map：使用LambdaMART进行列表平均排名，使平均平均精度（MAP）最大化。
    • reg:gamma：使用对数链接进行伽马回归。输出是伽马分布的平均值。
    • reg:tweedie：使用对数链接进行Tweedie回归。
    • 自定义损失函数和评价指标：https://xgboost.readthedocs.io/en/latest/tutorials/custom_metric_obj.html
  • eval_metric：验证数据的评估指标，将根据目标分配默认指标（回归均方根，分类误差，排名的平均平均精度），用户可以添加多个评估指标
    • rmse，均方根误差； rmsle：均方根对数误差； mae：平均绝对误差；mphe：平均伪Huber错误；logloss：负对数似然； error：二进制分类错误率；
    • merror：多类分类错误率； mlogloss：多类logloss； auc：曲线下面积； aucpr：PR曲线下的面积；ndcg：归一化累计折扣；map：平均精度；
  • seed ：随机数种子，[默认= 0]。

• 命令行参数（这里不说了，因为很少用命令行控制台版本）

XGBoost代码示例 Demo链接

from IPython.display import IFrame
IFrame('https://xgboost.readthedocs.io/en/latest/parameter.html', width=1400, height=800)

import pandas as pd
import xgboost as xgb 
from sklearn.datasets import make_friedman1

# 加载训练数据：         
wine = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data",header=None)
wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols','Flavanoids', 'Nonflavanoid phenols', 
                'Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline']

# 数据预处理
# 仅仅考虑2，3类葡萄酒，去除1类
wine = wine[wine['Class label'] != 1]
y = wine['Class label'].values
X = wine[['Alcohol','OD280/OD315 of diluted wines']].values

# 将分类标签变成二进制编码：
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y = le.fit_transform(y)

# 按8：2分割训练集和测试集
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)  # stratify参数代表了按照y的类别等比例抽样

# 将数据转为xgb格式 
dtrain = xgb.DMatrix(data = X_train, label = y_train)  
dtest  = xgb.DMatrix(data = X_test, label = y_test) 

# 设置XGB的参数，使用字典形式传入
param = {'max_depth':2, 'eta':1, 'objective':'binary:logistic' }   
num_round = 2     # 使用线程数a
bst = xgb.train(param, dtrain, num_round)   # 训练
# make prediction
preds = bst.predict(dtest)   # 预测

# 数据接口
## 1.LibSVM文本格式文件
dtrain = xgb.DMatrix('train.svm.txt')
dtest = xgb.DMatrix('test.svm.buffer')

## 2.CSV文件(不能含类别文本变量，如果存在文本变量请做特征处理如one-hot)
dtrain = xgb.DMatrix('train.csv?format=csv&label_column=0')
dtest = xgb.DMatrix('test.csv?format=csv&label_column=0')

## 3.NumPy数组
data = np.random.rand(5, 10)  # 5 entities, each contains 10 features
label = np.random.randint(2, size=5)  # binary target
dtrain = xgb.DMatrix(data, label=label)

## 4.scipy.sparse数组
csr = scipy.sparse.csr_matrix((dat, (row, col)))
dtrain = xgb.DMatrix(csr)

## pandas数据框dataframe
data = pandas.DataFrame(np.arange(12).reshape((4,3)), columns=['a', 'b', 'c'])
label = pandas.DataFrame(np.random.randint(2, size=4))
dtrain = xgb.DMatrix(data, label=label)

# 保存XGBoost格式到二进制文件中 再加载起来
## 1.保存DMatrix到XGBoost二进制文件中
dtrain = xgb.DMatrix('train.svm.txt')
dtrain.save_binary('train.buffer')
## 2. 缺少的值可以用DMatrix构造函数中的默认值替换：
dtrain = xgb.DMatrix(data, label=label, missing=-999.0)
## 3.可以在需要时设置权重：
w = np.random.rand(5, 1)
dtrain = xgb.DMatrix(data, label=label, missing=-999.0, weight=w)

# 加载并处理数据
df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data',header=None)
df_wine.columns = ['Class label', 'Alcohol','Malic acid', 'Ash','Alcalinity of ash','Magnesium', 'Total phenols',
                   'Flavanoids', 'Nonflavanoid phenols','Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline'] 
df_wine = df_wine[df_wine['Class label'] != 1]  # drop 1 class      
y = df_wine['Class label'].values
X = df_wine[['Alcohol','OD280/OD315 of diluted wines']].values
from sklearn.model_selection import train_test_split  # 切分训练集与测试集
from sklearn.preprocessing import LabelEncoder   # 标签化分类变量
le = LabelEncoder()
y = le.fit_transform(y)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test)

# 1.Booster 参数
params = {
    'booster': 'gbtree',
    'objective': 'multi:softmax',  # 多分类的问题
    'num_class': 10,               # 类别数，与 multisoftmax 并用
    'gamma': 0.1,                  # 用于控制是否后剪枝的参数,越大越保守，一般0.1、0.2这样子。
    'max_depth': 12,               # 构建树的深度，越大越容易过拟合
    'lambda': 2,                   # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
    'subsample': 0.7,              # 随机采样训练样本
    'colsample_bytree': 0.7,       # 生成树时进行的列采样
    'min_child_weight': 3,
    'silent': 1,                   # 设置成1则没有运行信息输出，最好是设置为0.
    'eta': 0.007,                  # 如同学习率
    'seed': 1000,
    'nthread': 4,                  # cpu 线程数
    'eval_metric':'auc'
}
plst = params.items()
# evallist = [(dtest, 'eval'), (dtrain, 'train')]   # 指定验证集

# 2.训练
num_round = 10
bst = xgb.train( plst, dtrain, num_round)
#bst = xgb.train( plst, dtrain, num_round, evallist )

# 3.保存模型
bst.save_model('0001.model')
# dump model
bst.dump_model('dump.raw.txt')
# dump model with feature map
#bst.dump_model('dump.raw.txt', 'featmap.txt')

# 4.加载保存的模型：
bst = xgb.Booster({'nthread': 4})  # init model
bst.load_model('0001.model')  # load data

# 5.也可以设置早停机制（需要设置验证集）
train(..., evals=evals, early_stopping_rounds=10)

# 6.预测
ypred = bst.predict(dtest)

# 1.绘制重要性
xgb.plot_importance(bst)
# 2.绘制输出树
# xgb.plot_tree(bst, num_trees=2)
# 3.使用xgboost.to_graphviz()将目标树转换为graphviz
# xgb.to_graphviz(bst, num_trees=2)

XGBoost案例

from sklearn.datasets import load_iris
import xgboost as xgb
from xgboost import plot_importance
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score   # 准确率
# 加载样本数据集
iris = load_iris()
X,y = iris.data,iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割

# 算法参数
params = {
    'booster': 'gbtree',
    'objective': 'multi:softmax',
    'num_class': 3,
    'gamma': 0.1,
    'max_depth': 6,
    'lambda': 2,
    'subsample': 0.7,
    'colsample_bytree': 0.75,
    'min_child_weight': 3,
    'silent': 0,
    'eta': 0.1,
    'seed': 1,
    'nthread': 4,
}

plst = params.items()

dtrain = xgb.DMatrix(X_train, y_train) # 生成数据集格式
num_rounds = 500
model = xgb.train(plst, dtrain, num_rounds) # xgboost模型训练

# 对测试集进行预测
dtest = xgb.DMatrix(X_test)
y_pred = model.predict(dtest)

# 计算准确率
accuracy = accuracy_score(y_test,y_pred)
print("accuarcy: %.2f%%" % (accuracy*100.0))

# 显示重要特征
plot_importance(model)
plt.show()

import xgboost as xgb
from xgboost import plot_importance
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston
from sklearn.metrics import mean_squared_error

# 加载数据集
boston = load_boston()
X,y = boston.data,boston.target

# XGBoost训练过程
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

params = {
    'booster': 'gbtree',
    'objective': 'reg:squarederror',
    'gamma': 0.1,
    'max_depth': 5,
    'lambda': 3,
    'subsample': 0.7,
    'colsample_bytree': 0.7,
    'min_child_weight': 3,
    'silent': 1,
    'eta': 0.1,
    'seed': 1000,
    'nthread': 4,
}

dtrain = xgb.DMatrix(X_train, y_train)
num_rounds = 300
plst = params.items()
model = xgb.train(plst, dtrain, num_rounds)

# 对测试集进行预测
dtest = xgb.DMatrix(X_test)
ans = model.predict(dtest)

# 显示重要特征
plot_importance(model)
plt.show()

调参与模型搜索法

import xgboost as xgb
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import roc_auc_score

iris = load_iris()
X,y = iris.data,iris.target
col = iris.target_names 
train_x, valid_x, train_y, valid_y = train_test_split(X, y, test_size=0.3, random_state=1)   # 分训练集和验证集
parameters = {
              'max_depth': [5, 10, 15, 20, 25],
              'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
              'n_estimators': [500, 1000, 2000, 3000, 5000],
              'min_child_weight': [0, 2, 5, 10, 20],
              'max_delta_step': [0, 0.2, 0.6, 1, 2],
              'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
              'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
              'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
              'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
              'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1]

}

xlf = xgb.XGBClassifier(max_depth=10,
            learning_rate=0.01,
            n_estimators=2000,
            silent=True,
            objective='multi:softmax',
            num_class=3 ,          
            nthread=-1,
            gamma=0,
            min_child_weight=1,
            max_delta_step=0,
            subsample=0.85,
            colsample_bytree=0.7,
            colsample_bylevel=1,
            reg_alpha=0,
            reg_lambda=1,
            scale_pos_weight=1,
            seed=0,
            missing=None)

gs = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
gs.fit(train_x, train_y)

print("Best score: %0.3f" % gs.best_score_)
print("Best parameters set: %s" % gs.best_params_ )

6. LightGBM算法

LightGBM也是像XGBoost一样，是一类集成算法，他跟XGBoost总体来说是一样的，算法本质上与Xgboost没有出入，只是在XGBoost的基础上进行了优化，因此就不对原理进行重复介绍，在这里我们来看看几种算法的差别：

• 优化速度和内存使用
  • 降低了计算每个分割增益的成本。
  • 使用直方图减法进一步提高速度。
  • 减少内存使用。
  • 减少并行学习的计算成本。
• 稀疏优化
  • 用离散的bin替换连续的值。如果#bins较小，则可以使用较小的数据类型（例如uint8_t）来存储训练数据 。
  • 无需存储其他信息即可对特征数值进行预排序 。
• 精度优化
  • 使用叶子数为导向的决策树建立算法而不是树的深度导向。
  • 分类特征的编码方式的优化
  • 通信网络的优化
  • 并行学习的优化
  • GPU支持

LightGBM的优点：
　　1）更快的训练效率
　　2）低内存使用
　　3）更高的准确率
　　4）支持并行化学习
　　5）可以处理大规模数据

LightGBM参数说明：
推荐文档1：https://lightgbm.apachecn.org/#/docs/6
推荐文档2：https://lightgbm.readthedocs.io/en/latest/Parameters.html

LightGBM与网格搜索结合调参：
参考代码：https://blog.youkuaiyun.com/u012735708/article/details/83749703

import lightgbm as lgb
from sklearn import metrics
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
 
canceData=load_breast_cancer()
X=canceData.data
y=canceData.target
X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0,test_size=0.2)
 
### 数据转换
print('数据转换')
lgb_train = lgb.Dataset(X_train, y_train, free_raw_data=False)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train,free_raw_data=False)
 
### 设置初始参数--不含交叉验证参数
print('设置参数')
params = {
          'boosting_type': 'gbdt',
          'objective': 'binary',
          'metric': 'auc',
          'nthread':4,
          'learning_rate':0.1
          }
 
### 交叉验证(调参)
print('交叉验证')
max_auc = float('0')
best_params = {}
 
# 准确率 加深模型 -> 加大深度 提高叶子树
print("调参1：提高准确率")
for num_leaves in range(5,100,5):
    for max_depth in range(3,8,1):
        params['num_leaves'] = num_leaves
        params['max_depth'] = max_depth
 
        cv_results = lgb.cv(
                            params,
                            lgb_train,
                            seed=1,
                            nfold=5,
                            metrics=['auc'],
                            early_stopping_rounds=10,
                            verbose_eval=True
                            )
            
        mean_auc = pd.Series(cv_results['auc-mean']).max()
        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
            
        if mean_auc >= max_auc:
            max_auc = mean_auc
            best_params['num_leaves'] = num_leaves
            best_params['max_depth'] = max_depth
if 'num_leaves' and 'max_depth' in best_params.keys():          
    params['num_leaves'] = best_params['num_leaves']
    params['max_depth'] = best_params['max_depth']
 
# 过拟合 剪枝 -> 每个叶子节点最小的数量
print("调参2：降低过拟合")
for max_bin in range(5,256,10):
    for min_data_in_leaf in range(1,102,10):
            params['max_bin'] = max_bin
            params['min_data_in_leaf'] = min_data_in_leaf
            
            cv_results = lgb.cv(
                                params,
                                lgb_train,
                                seed=1,
                                nfold=5,
                                metrics=['auc'],
                                early_stopping_rounds=10,
                                verbose_eval=True
                                )
                    
            mean_auc = pd.Series(cv_results['auc-mean']).max()
            boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
 
            if mean_auc >= max_auc:
                max_auc = mean_auc
                best_params['max_bin']= max_bin
                best_params['min_data_in_leaf'] = min_data_in_leaf
if 'max_bin' and 'min_data_in_leaf' in best_params.keys():
    params['min_data_in_leaf'] = best_params['min_data_in_leaf']
    params['max_bin'] = best_params['max_bin']
 
print("调参3：降低过拟合")  # 
for feature_fraction in [0.6,0.7,0.8,0.9,1.0]:
    for bagging_fraction in [0.6,0.7,0.8,0.9,1.0]:
        for bagging_freq in range(0,50,5):
            params['feature_fraction'] = feature_fraction
            params['bagging_fraction'] = bagging_fraction
            params['bagging_freq'] = bagging_freq
            
            cv_results = lgb.cv(
                                params,
                                lgb_train,
                                seed=1,
                                nfold=5,
                                metrics=['auc'],
                                early_stopping_rounds=10,
                                verbose_eval=True
                                )
                    
            mean_auc = pd.Series(cv_results['auc-mean']).max()
            boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
 
            if mean_auc >= max_auc:
                max_auc=mean_auc
                best_params['feature_fraction'] = feature_fraction
                best_params['bagging_fraction'] = bagging_fraction
                best_params['bagging_freq'] = bagging_freq
 
if 'feature_fraction' and 'bagging_fraction' and 'bagging_freq' in best_params.keys():
    params['feature_fraction'] = best_params['feature_fraction']
    params['bagging_fraction'] = best_params['bagging_fraction']
    params['bagging_freq'] = best_params['bagging_freq']
 
 
print("调参4：降低过拟合")
for lambda_l1 in [1e-5,1e-3,1e-1,0.0,0.1,0.3,0.5,0.7,0.9,1.0]:
    for lambda_l2 in [1e-5,1e-3,1e-1,0.0,0.1,0.4,0.6,0.7,0.9,1.0]:
        params['lambda_l1'] = lambda_l1
        params['lambda_l2'] = lambda_l2
        cv_results = lgb.cv(
                            params,
                            lgb_train,
                            seed=1,
                            nfold=5,
                            metrics=['auc'],
                            early_stopping_rounds=10,
                            verbose_eval=True
                            )
                
        mean_auc = pd.Series(cv_results['auc-mean']).max()
        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
 
        if mean_auc >= max_auc:
            max_auc=mean_auc
            best_params['lambda_l1'] = lambda_l1
            best_params['lambda_l2'] = lambda_l2
if 'lambda_l1' and 'lambda_l2' in best_params.keys():
    params['lambda_l1'] = best_params['lambda_l1']
    params['lambda_l2'] = best_params['lambda_l2']
 
print("调参5：降低过拟合2")
for min_split_gain in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
    params['min_split_gain'] = min_split_gain
    
    cv_results = lgb.cv(
                        params,
                        lgb_train,
                        seed=1,
                        nfold=5,
                        metrics=['auc'],
                        early_stopping_rounds=10,
                        verbose_eval=True
                        )
            
    mean_auc = pd.Series(cv_results['auc-mean']).max()
    boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
 
    if mean_auc >= max_auc:
        max_auc=mean_auc
        
        best_params['min_split_gain'] = min_split_gain
if 'min_split_gain' in best_params.keys():
    params['min_split_gain'] = best_params['min_split_gain']
 
print(best_params)

课后作业

数据处理

#importing standard libraries 
import numpy as np 
import pandas as pd 
from pandas import Series, DataFrame 

#import lightgbm and xgboost 
import lightgbm as lgb 
import xgboost as xgb 

#loading our training dataset 'adult.csv' with name 'data' using pandas 
# Dataset: http://archive.ics.uci.edu/ml/datasets/Adult
data=pd.read_csv('adult.csv',header=None) 

#Assigning names to the columns 
data.columns=['age','workclass','fnlwgt','education','education-num','marital_Status','occupation','relationship','race','sex','capital_gain','capital_loss','hours_per_week','native_country','Income'] 

#glimpse of the dataset 
data.head() 

# Label Encoding our target variable 
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
l=LabelEncoder() 
l.fit(data.Income) 

l.classes_ 
data.Income=Series(l.transform(data.Income))  #label encoding our target variable 
data.Income.value_counts() 

 

#One Hot Encoding of the Categorical features 
one_hot_workclass=pd.get_dummies(data.workclass) 
one_hot_education=pd.get_dummies(data.education) 
one_hot_marital_Status=pd.get_dummies(data.marital_Status) 
one_hot_occupation=pd.get_dummies(data.occupation)
one_hot_relationship=pd.get_dummies(data.relationship) 
one_hot_race=pd.get_dummies(data.race) 
one_hot_sex=pd.get_dummies(data.sex) 
one_hot_native_country=pd.get_dummies(data.native_country) 

#removing categorical features 
data.drop(['workclass','education','marital_Status','occupation','relationship','race','sex','native_country'],axis=1,inplace=True) 

 

#Merging one hot encoded features with our dataset 'data' 
data=pd.concat([data,one_hot_workclass,one_hot_education,one_hot_marital_Status,one_hot_occupation,one_hot_relationship,one_hot_race,one_hot_sex,one_hot_native_country],axis=1) 

#removing dulpicate columns 
 _, i = np.unique(data.columns, return_index=True) 
data=data.iloc[:, i] 

#Here our target variable is 'Income' with values as 1 or 0.  
#Separating our data into features dataset x and our target dataset y 
x=data.drop('Income',axis=1) 
y=data.Income 

 

#Imputing missing values in our target variable 
y.fillna(y.mode()[0],inplace=True) 

#Now splitting our dataset into test and train 
from sklearn.model_selection import train_test_split 
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=.3)

Applying XGBoost

#The data is stored in a DMatrix object 
#label is used to define our outcome variable
dtrain=xgb.DMatrix(x_train,label=y_train)
dtest=xgb.DMatrix(x_test)

#setting parameters for xgboost
parameters={'max_depth':7, 'eta':1, 'silent':1,'objective':'binary:logistic','eval_metric':'auc','learning_rate':.05}

#training our model 
num_round=50
from datetime import datetime 
start = datetime.now() 
xg=xgb.train(parameters,dtrain,num_round) 
stop = datetime.now()

#Execution time of the model 
execution_time_xgb = stop-start 
execution_time_xgb

#datetime.timedelta( , , ) representation => (days , seconds , microseconds) 
#now predicting our model on test set 
ypred=xg.predict(dtest) 
ypred

#Converting probabilities into 1 or 0  
for i in range(0,9769): 
    if ypred[i]>=.5:       # setting threshold to .5 
       ypred[i]=1 
    else: 
       ypred[i]=0  

#calculating accuracy of our model 
from sklearn.metrics import accuracy_score 
accuracy_xgb = accuracy_score(y_test,ypred) 
accuracy_xgb

Light GBM

train_data=lgb.Dataset(x_train,label=y_train)

#setting parameters for lightgbm
param = {'num_leaves':150, 'objective':'binary','max_depth':7,'learning_rate':.05,'max_bin':200}
param['metric'] = ['auc', 'binary_logloss']

# Here we have set max_depth in xgb and LightGBM to 7 to have a fair comparison between the two.

#training our model using light gbm
num_round=50
start=datetime.now()
lgbm=lgb.train(param,train_data,num_round)
stop=datetime.now()

#Execution time of the model
execution_time_lgbm = stop-start
execution_time_lgbm

#predicting on test set
ypred2=lgbm.predict(x_test)
ypred2[0:5]  # showing first 5 predictions

#converting probabilities into 0 or 1
for i in range(0,9769):
    if ypred2[i]>=.5:       # setting threshold to .5
       ypred2[i]=1
    else:  
       ypred2[i]=0

#calculating accuracy
accuracy_lgbm = accuracy_score(ypred2,y_test)
accuracy_lgbm
y_test.value_counts()

from sklearn.metrics import roc_auc_score

#calculating roc_auc_score for xgboost
auc_xgb =  roc_auc_score(y_test,ypred)
auc_xgb

#calculating roc_auc_score for light gbm. 
auc_lgbm = roc_auc_score(y_test,ypred2)
auc_lgbm comparison_dict = {'accuracy score':(accuracy_lgbm,accuracy_xgb),'auc score':(auc_lgbm,auc_xgb),'execution time':(execution_time_lgbm,execution_time_xgb)}

#Creating a dataframe ‘comparison_df’ for comparing the performance of Lightgbm and xgb. 
comparison_df = DataFrame(comparison_dict) 
comparison_df.index= ['LightGBM','xgboost'] 
comparison_df

结果

与XGBOOST相比，通过应用Light GBM只能使准确性和auc得分略有提高，但是训练过程的执行时间却存在显着差异。 轻型GBM几乎比XGBOOST快7倍，是处理大型数据集时更好的方法。

轻型GBM使用逐叶拆分而不是深度拆分，这使其可以更快地收敛，但也会导致过度拟合。 因此，这是在Light GBM中调整参数的快速指南。

为了最合适

• num_leaves：此参数用于设置要在树中形成的叶子数。理论上，num_leaves和 max_depth之间的关系是num_leaves = 2 ^（max_depth）。但是，对于Light GBM，这不是一个好的估计，因为拆分是按叶方式而不是深度方式进行的。因此，num_leaves设置必须小于2 ^（max_depth），否则可能导致过度拟合。轻型GBM在num_leaves和max_depth之间没有直接关系，因此不能将两者链接在一起。
• min_data_in_leaf：它也是处理过度拟合的重要参数之一。将其值设置得较小可能会导致过拟合，因此必须进行相应设置。它的值应该是数百到数千个大型数据集。
  max_depth：指定树可以生长的最大深度或级别。

更快的速度

• bagging_fraction：用于执行装袋以获得更快的结果
• feature_fraction：设置每次迭代要使用的特征的比例
• max_bin：较小的max_bin值可以将特征值存储在离散的bin中，因此可以节省大量时间，这在计算上不昂贵。

为了更好的准确性
使用更大的训练数据

• num_leaves：将其设置为较高的值会产生精度更高的更深树，但会导致过度拟合。因此，其较高的值不是优选的。
• max_bin：将其设置为较高的值具有与num_leaves的值增加所引起的相似效果，并且也减慢了我们的训练过程。

参考资料：
官方文档
萌弟知乎的总结
LGBM和XGBoost实例