一、集成学习算法简介

1 什么是集成学习

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

2 复习：机器学习的两个核心任务

• 任务一：如何优化训练数据 —> 主要用于解决欠拟合问题
• 任务二：如何提升泛化性能 —> 主要用于解决过拟合问题

3 集成学习中boosting和Bagging

只要单分类器的表现不太差，集成学习的结果总是要好于单分类器的

二、Bagging和随机森林

1 Bagging集成原理

目标：把下面的圈和方块进行分类

实现过程：

1. 采样不同数据集
   

2. 训练分类器
   

3. 平权投票，获取最终结果
   

4. 主要实现过程小结
   

2 随机森林构造过程

在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。

随机森林 = Bagging + 决策树

例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个树的结果是False, 那么最终投票结果就是True

随机森林构造过程中的关键步骤(M表示特征数目)：

​ 1)一次随机选出一个样本，有放回的抽样，重复N次(有可能出现重复的样本)

​ 2) 随机去选出m个特征, m <<M，建立决策树

思考

1. 为什么要随机抽样训练集？　　
   如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
2. 为什么要有放回地抽样？
   如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”(当然这样说可能不对)，也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树(弱分类器)的投票表决。

3 包外估计 (Out-of-Bag Estimate)

在随机森林构造过程中，如果进行有放回的抽样，我们会发现，总是有一部分样本我们选不到。

• 这部分数据，占整体数据的比重有多大呢？
• 这部分数据有什么用呢？

3.1 包外估计的定义

随机森林的 Bagging 过程，对于每一颗训练出的决策树 $g_t$，与数据集 $D$ 有如下关系：

对于星号的部分，即是没有选择到的数据，称之为 Out-of-bag(OOB)数据，当数据足够多，对于任意一组数据 $(x_n,y_n)$ 是包外数据的概率为：

由于基分类器是构建在训练样本的自助抽样集上的，只有约 $63.2\%$ 原样本集出现在中，而剩余的 $36.8\%$ 的数据作为包外数据，可以用于基分类器的验证集。

经验证，包外估计是对集成分类器泛化误差的无偏估计

在随机森林算法中数据集属性的重要性、分类器集强度和分类器间相关性计算都依赖于袋外数据。

什么是无偏估计：参考

3.2 包外估计的用途

• 当基学习器是决策树时，可使用包外样本来辅助剪枝 ，或用于估计决策树中各结点的后验概率以辅助对零训练样本结点的处理；
• 当基学习器是神经网络时，可使用包外样本来辅助早期停止以减小过拟合 。

4 随机森林api介绍

sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=’gini’, max_depth=None, bootstrap=True, random_state=None, min_samples_split=2)

• n_estimators：integer，optional(default = 10)森林里的树木数量120,200,300,500,800,1200
  在利用最大投票数或平均值来预测之前，你想要建立子树的数量。

• Criterion：string，可选(default =“gini”)
  分割特征的测量方法

• max_depth：integer或None，可选(默认=无)
  树的最大深度 5,8,15,25,30

• 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：boolean，optional(default = True)
  是否在构建树时使用放回抽样

• min_samples_split 内部节点再划分所需最小样本数

  这个值限制了子树继续划分的条件，如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分，默认是2。

  如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。

• min_samples_leaf 叶子节点的最小样本数

  这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝， 默认是1。

  叶是决策树的末端节点。 较小的叶子使模型更容易捕捉训练数据中的噪声。

  一般来说，我更偏向于将最小叶子节点数目设置为大于50。

• min_impurity_split: 节点划分最小不纯度
  这个值限制了决策树的增长，如果某节点的不纯度(基于基尼系数，均方差)小于这个阈值，则该节点不再生成子节点。即为叶子节点 。

  一般不推荐改动默认值1e-7。

• 上面决策树参数中最重要的包括

  • 最大特征数max_features
  • 最大深度max_depth
  • 内部节点再划分所需最小样本数min_samples_split
  • 叶子节点最少样本数min_samples_leaf

5 随机森林预测案例

基于泰坦尼克号乘客生存预测案例的x_train，y_train进行训练

实例化随机森林

from sklearn.ensemble import RandomForestClassifier
# 随机森林去进行预测
rf = RandomForestClassifier()

定义超参数的选择列表

from sklearn.model_selection import GridSearchCV
param = {"n_estimators": [120,200,300,500,800,1200], "max_depth": [5, 8, 15, 25, 30]}

使用GridSearchCV进行网格搜索

# 超参数调优
gc = GridSearchCV(rf, param_grid=param, cv=2)

gc.fit(x_train, y_train)

print("随机森林预测的准确率为：", gc.score(x_test, y_test))

注意：

• 随机森林的建立过程
• 树的深度、树的个数等需要进行超参数调优

6 bagging集成优点

​ Bagging + 决策树/线性回归/逻辑回归/深度学习… = bagging集成学习方法

经过上面方式组成的集成学习方法:

• 均可在原有算法上提高约2%左右的泛化正确率
• 简单, 方便, 通用

三、otto案例介绍 – Otto Group Product Classification Challenge

1.背景介绍

奥托集团是世界上最大的电子商务公司之一，在20多个国家设有子公司。该公司每天都在世界各地销售数百万种产品,所以对其产品根据性能合理的分类非常重要。

不过,在实际工作中,工作人员发现,许多相同的产品得到了不同的分类。本案例要求,你对奥拓集团的产品进行正确的分类。尽可能的提供分类的准确性。

链接：https://www.kaggle.com/c/otto-group-product-classification-challenge/overview

2.数据集介绍

• 本案例中，数据集包含大约200,000种产品的93个特征。
• 其目的是建立一个能够区分otto公司主要产品类别的预测模型。
• 所有产品共被分成九个类别（例如时装，电子产品等）。

• id - 产品id
• feat_1, feat_2, …, feat_93 - 产品的各个特征
• target - 产品被划分的类别

3.评分标准

本案例中，最后结果使用多分类对数损失进行评估。

具体公式：

上公式中，

• $i$ 表示样本，$j$ 表示类别。$P_{ij}$ 代表第 $i$ 个样本属于类别j的概率，
• 如果第 $i$ 个样本真的属于类别 $j$，则$y_{ij}$等于1，否则为0。
• 根据上公式，假如你将所有的测试样本都正确分类，所有 $p_{ij}$ 都是1，那每个$log(p_{ij})$都是0，最终的 $logloss$ 也是0。
• 假如第1个样本本来是属于1类别的，但是你给它的类别概率 $p_{ij}=0.1$，那 $logloss$ 就会累加上 $log(0.1)$ 这一项。我们知道这一项是负数，而且 $p_{ij}$ 越小，负得越多，如果pij=0，将是无穷。这会导致这种情况：你分错了一个，$logloss$ 就是无穷。这当然不合理，为了避免这一情况，我们对非常小的值做如下处理：
  $$max(min(p,1-10^{-15}),10^{-15})$$
• 也就是说最小不会小于 $10^{-15}$

4.实现过程

4.1 流程分析

• 获取数据
• 数据基本处理
  • 数据量比较大，尝试是否可以进行数据分割
  • 转换目标值表示方式
• 模型训练
  • 模型基本训练

4.2 代码实现

数据基本展示

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# 导入数据
data = pd.read_csv("./data/otto/train.csv")

# 图形可视化，查看数据分布
sns.countplot(data.target)
plt.show()

数据基本处理

截取部分数据

# 首先需要确定标签值
y = data["target"]
x = data.drop(["id","target"],axis=1)

# 欠采样获取数据
from imblearn.under_sampling import RandomUnderSampler
rus = RandomUnderSampler(random_state=0)
X_resampled, y_resampled = rus.fit_resample(x,y)

print(X_resampled.shape,y_resampled.shape)
# (17361, 93) (17361,)

# 图形可视化，查看数据分布
sns.countplot(y_resampled)
plt.show()

可以看到经过欠采样以后数据的分布平衡了

把标签值转换成数字

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
y_resampled = le.fit_transform(y_resampled)
print(y_resampled)
# [0 0 0 ... 8 8 8]

分割数据

from sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test = train_test_split(X_resampled,y_resampled,test_size=0.2)
print(x_train.shape,y_train.shape)	# (13888, 93) (13888,)
print(x_test.shape,y_test.shape)	# (3473, 93) (3473,)

基本模型训练

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(oob_score=True)
rf.fit(x_train,y_train)

y_pre = rf.predict(x_test)
y_pre	#array([4, 3, 3, ..., 1, 8, 3])

rf.score(x_test, y_test)	#0.7817448891448315
rf.oob_score_	#0.7626008064516129

# 图形可视化,查看数据分布
sns.countplot(y_pre)
plt.show()

# logloss模型评估
from sklearn.metrics import log_loss

log_loss(y_test, y_pre, eps=1e-15, normalize=True)

这里报了错：y_true and y_pred contain different number of classes 9, 2. Please provide the true labels explicitly through the labels argument. Classes found in y_true: [0 1 2 3 4 5 6 7 8]
解决办法就是将y值改为独热编码

from sklearn.preprocessing import OneHotEncoder

one_hot = OneHotEncoder(sparse=False)

y_test1 = one_hot.fit_transform(y_test.reshape(-1,1))
y_pre1 = one_hot.fit_transform(y_pre.reshape(-1,1))

# logloss模型评估
log_loss(y_test1, y_pre1, eps=1e-15, normalize=True)
# 7.538264470873115

# 改变预测值的输出模式,让输出结果为百分占比,降低logloss值
y_pre_proba = rf.predict_proba(x_test)

# logloss模型评估
log_loss(y_test1, y_pre_proba, eps=1e-15, normalize=True)
# 0.7378124652239569

模型调优

n_estimators, max_feature, max_depth, min_samples_leaf

确定最优的n_estimators

# 确定n_estimators的取值范围
tuned_parameters = range(10, 200, 10)

# 创建添加accuracy的一个numpy
accuracy_t = np.zeros(len(tuned_parameters))

# 创建添加error的一个numpy
error_t = np.zeros(len(tuned_parameters))

# 调优过程实现
for j, one_parameter in enumerate(tuned_parameters):
    rf2 = RandomForestClassifier(n_estimators=one_parameter, 
                                 max_depth=10, 
                                 max_features=10, 
                                 min_samples_leaf=10, 
                                 oob_score=True, 
                                 random_state=0, 
                                 n_jobs=-1)
    
    rf2.fit(x_train, y_train)
    
    # 输出accuracy
    accuracy_t[j] = rf2.oob_score_
    
    # 输出log_loss
    y_pre = rf2.predict_proba(x_test)
    error_t[j] = log_loss(y_test, y_pre, eps=1e-15, normalize=True)
    
    print(error_t)

# 优化结果过程可视化
fig,axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 4), dpi=100)

axes[0].plot(tuned_parameters, error_t)
axes[1].plot(tuned_parameters, accuracy_t)

axes[0].set_xlabel("n_estimators")
axes[0].set_ylabel("error_t")
axes[1].set_xlabel("n_estimators")
axes[1].set_ylabel("accuracy_t")

axes[0].grid(True)
axes[1].grid(True)

plt.show()

经过图像展示,最后确定n_estimators=175的时候,表现效果不错

确定最优的max_features

# 确定max_features的取值范围
tuned_parameters = range(5, 40, 5)

# 创建添加accuracy的一个numpy
accuracy_t = np.zeros(len(tuned_parameters))

# 创建添加error的一个numpy
error_t = np.zeros(len(tuned_parameters))

# 调优过程实现
for j, one_parameter in enumerate(tuned_parameters):
    rf2 = RandomForestClassifier(n_estimators=175, 
                                 max_depth=10, 
                                 max_features=one_parameter, 
                                 min_samples_leaf=10, 
                                 oob_score=True, 
                                 random_state=0, 
                                 n_jobs=-1)
    
    rf2.fit(x_train, y_train)
    
    # 输出accuracy
    accuracy_t[j] = rf2.oob_score_
    
    # 输出log_loss
    y_pre = rf2.predict_proba(x_test)
    error_t[j] = log_loss(y_test, y_pre, eps=1e-15, normalize=True)
    
    print(error_t)

# 优化结果过程可视化
fig,axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 4), dpi=100)

axes[0].plot(tuned_parameters, error_t)
axes[1].plot(tuned_parameters, accuracy_t)

axes[0].set_xlabel("max_features")
axes[0].set_ylabel("error_t")
axes[1].set_xlabel("max_features")
axes[1].set_ylabel("accuracy_t")

axes[0].grid(True)
axes[1].grid(True)

plt.show()

经过图像展示,最后确定max_features=15的时候,表现效果不错

确定最优的max_depth

# 确定max_depth的取值范围
tuned_parameters = range(10, 100, 10)

# 创建添加accuracy的一个numpy
accuracy_t = np.zeros(len(tuned_parameters))

# 创建添加error的一个numpy
error_t = np.zeros(len(tuned_parameters))

# 调优过程实现
for j, one_parameter in enumerate(tuned_parameters):
    rf2 = RandomForestClassifier(n_estimators=175, 
                                 max_depth=one_parameter, 
                                 max_features=15, 
                                 min_samples_leaf=10, 
                                 oob_score=True, 
                                 random_state=0, 
                                 n_jobs=-1)
    
    rf2.fit(x_train, y_train)
    
    # 输出accuracy
    accuracy_t[j] = rf2.oob_score_
    
    # 输出log_loss
    y_pre = rf2.predict_proba(x_test)
    error_t[j] = log_loss(y_test, y_pre, eps=1e-15, normalize=True)
    
    print(error_t)

# 优化结果过程可视化
fig,axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 4), dpi=100)

axes[0].plot(tuned_parameters, error_t)
axes[1].plot(tuned_parameters, accuracy_t)

axes[0].set_xlabel("max_depth")
axes[0].set_ylabel("error_t")
axes[1].set_xlabel("max_depth")
axes[1].set_ylabel("accuracy_t")

axes[0].grid(True)
axes[1].grid(True)

plt.show()

经过图像展示,最后确定max_depth=30的时候,表现效果不错

确定最优的min_sample_leaf

# 确定min_sample_leaf的取值范围
tuned_parameters = range(1, 10, 2)

# 创建添加accuracy的一个numpy
accuracy_t = np.zeros(len(tuned_parameters))

# 创建添加error的一个numpy
error_t = np.zeros(len(tuned_parameters))

# 调优过程实现
for j, one_parameter in enumerate(tuned_parameters):
    rf2 = RandomForestClassifier(n_estimators=175, 
                                 max_depth=30, 
                                 max_features=15, 
                                 min_samples_leaf=one_parameter, 
                                 oob_score=True, 
                                 random_state=0, 
                                 n_jobs=-1)
    
    rf2.fit(x_train, y_train)
    
    # 输出accuracy
    accuracy_t[j] = rf2.oob_score_
    
    # 输出log_loss
    y_pre = rf2.predict_proba(x_test)
    error_t[j] = log_loss(y_test, y_pre, eps=1e-15, normalize=True)
    
    print(error_t)

# 优化结果过程可视化
fig,axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 4), dpi=100)

axes[0].plot(tuned_parameters, error_t)
axes[1].plot(tuned_parameters, accuracy_t)

axes[0].set_xlabel("min_sample_leaf")
axes[0].set_ylabel("error_t")
axes[1].set_xlabel("min_sample_leaf")
axes[1].set_ylabel("accuracy_t")

axes[0].grid(True)
axes[1].grid(True)

plt.show()

经过图像展示,最后确定min_sample_leaf=1的时候,表现效果不错

确定最优模型

n_estimators=175
max_depth=30
max_features=15
min_samples_leaf=1

rf3 = RandomForestClassifier(n_estimators=175,
                             max_depth=30,
                             max_features=15,
                             min_samples_leaf=1,
                             oob_score=True,
                             random_state=40,
                             n_jobs=-1)

rf3.fit(x_train, y_train)

rf3.score(x_test, y_test)
# 0.7788655341203571

rf3.oob_score_
# 0.7693692396313364

y_pre_proba1 = rf3.predict_proba(x_test)
log_loss(y_test, y_pre_proba1)
# 0.7018021583384667

生成提交数据

test_data = pd.read_csv("./data/otto/test.csv")
test_data_drop_id = test_data.drop(["id"], axis=1)

y_pre_test = rf3.predict_proba(test_data_drop_id)

result_data = pd.DataFrame(y_pre_test, columns=["Class_"+str(i) for i in range(1, 10)])

result_data.insert(loc=0, column="id", value=test_data.id)

result_data.to_csv("./data/otto/submission.csv", index=False)

之后将csv文件提交到kaggle上就可以了

四、Boosting

1 什么是boosting

随着学习的积累从弱到强

简而言之：每新加入一个弱学习器，整体能力就会得到提升

代表算法：Adaboost，GBDT，XGBoost，LightGBM

2 实现过程

1. 训练第一个学习器
   
2. 调整数据分布
   
3. 训练第二个学习器
   
4. 再次调整数据分布
   
5. 依次训练学习器，调整数据分布
   
6. 整体过程实现
   

3 bagging集成与boosting集成的区别

区别一:数据方面

• Bagging：对数据进行采样训练；
• Boosting：根据前一轮学习结果调整数据的重要性。

区别二:投票方面

• Bagging：所有学习器平权投票；
• Boosting：对学习器进行加权投票。

区别三:学习顺序

• Bagging的学习是并行的，每个学习器没有依赖关系；
• Boosting学习是串行，学习有先后顺序。

区别四:主要作用

• Bagging主要用于提高泛化性能（解决过拟合，也可以说降低方差）
• Boosting主要用于提高训练精度 （解决欠拟合，也可以说降低偏差）

4 AdaBoost介绍

4.1 构造过程细节

4.2 关键点剖析

如何确认投票权重？

如何调整数据分布？

4.3 案例

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

问题解答：

4.4 api介绍

from sklearn.ensemble import AdaBoostClassifier

api介绍链接：点这

api的使用方法和前面差不多，可以动手试一试

五、GBDT介绍

GBDT 的全称是 Gradient Boosting Decision Tree，梯度提升树，在传统机器学习算法中，GBDT算的上TOP3的算法。想要理解GBDT的真正意义，那就必须理解GBDT中的Gradient Boosting 和Decision Tree分别是什么？

1 Decision Tree：CART回归树

首先，GBDT使用的决策树是CART回归树，无论是处理回归问题还是二分类以及多分类，GBDT使用的决策树通通都是都是CART回归树。

• 为什么不用CART分类树呢？
  • 因为GBDT每次迭代要拟合的是梯度值，是连续值所以要用回归树。

对于回归树算法来说最重要的是寻找最佳的划分点，那么回归树中的可划分点包含了所有特征的所有可取的值。

在分类树中最佳划分点的判别标准是熵或者基尼系数，都是用纯度来衡量的，但是在回归树中的样本标签是连续数值，所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。

1.1 回归树生成算法（复习）

2 Gradient Boosting： 拟合负梯度

梯度提升树（Grandient Boosting）是提升树（Boosting Tree）的一种改进算法，所以在讲梯度提升树之前先来说一下提升树。

先来个通俗理解：假如有个人30岁，我们首先用20岁去拟合，发现损失有10岁，这时我们用6岁去拟合剩下的损失，发现差距还有4岁，第三轮我们用3岁拟合剩下的差距，差距就只有一岁了。如果我们的迭代轮数还没有完，可以继续迭代下面，每一轮迭代，拟合的岁数误差都会减小。最后将每次拟合的岁数加起来便是模型输出的结果。

当损失函数是平方损失和指数损失函数时，梯度提升树每一步优化是很简单的，但是对于一般损失函数而言，往往每一步优化起来不那么容易。

针对这一问题，Friedman提出了梯度提升树算法，这是利用最速下降的近似方法，其关键是利用损失函数的负梯度作为提升树算法中的残差的近似值。

那么负梯度长什么样呢？

此时我们发现GBDT的负梯度就是残差，所以说对于回归问题，我们要拟合的就是残差。

那么对于分类问题呢？

• 二分类和多分类的损失函数都是logloss。

本文以回归问题为例进行讲解。

3 GBDT算法原理

上面两节分别将Decision Tree和Gradient Boosting介绍完了，下面将这两部分组合在一起就是我们的GBDT了。

4 实例介绍

4.1 数据介绍

根据如下数据，预测最后一个样本的身高。

4.2 模型训练

4.2.1 设置参数

• 学习率：learning_rate=0.1
• 迭代次数：n_trees=5
• 树的深度：max_depth=3

4.2.2 开始训练

1. 初始化弱学习器
   
2. 对迭代轮数m=1,2,…,M
   
   
   
   
   
   
   
   
   
3. 得到最后的强学习器
   
4. 预测样本
   

上一篇：机器学习：决策树
下一篇：机器学习：聚类算法

一、实验目标

了解集成学习的基本结构、训练方法、实现方法，并通过随机森林与Adaboost算法加深理解。

二、实验内容

概念
集成学习(Ensemble learning)通过构建并结合多个学习器来完成学习任务，有时也被称为多分类器系统、基于委员会的学习等，集成学习通常可以获得比单一学习模型更好的泛化性。
基本结构
先产生多个“个体学习器”，也叫做“基学习器”，再用某种策略将它们结合起来，集成中只包含同种类型的个体学习器叫做同质，包含不同类型的个体学习器叫做异质。要获得好的集成就应该找到“好而不同”的个体学习器，这就是集成学习的研究核心。
理论理解

图1.分类错误率

图2.投票法
sign：表示输入小于零时，结果为0；当输入大于零时，结果为1.

图3.hoeffding不等式
通过分析可知，随着集成的个体分类模型的个数T增加，集成模型的错误率呈指数级下降，且个体分类模型的错误率ε越小，集成模型的错误率也越小。
所以我们可以通过增加T，即增加个体学习器的个数，和减小ε，来得到更好的效果。
在集成学习中，如果个体学习模型之间的差异很小，集成之后的模型与个体模型之间的并没有明显的差别，集成的效果不明显。下图所示的是个体分类模型对集成结果的影响

图4.效果对比
通过上述例子我们可以看出，要想获得更好的集成性能，基学习器要满足两个条件

• 基学习器的准确率不低于50%
• 基学习器要有差异，不能完全相同

Boosting
Boosting是一簇可将弱学习器提升为强学习器的算法。其工作机制为：

• 先从初始训练集训练出一个基学习器
• 再根据基学习器的表现对样本分布进行调整，使得先前的基学习器做错的训练样本在后续收到更多的关注
• 然后基于调整后的样本分布来训练下一个基学习器；如此重复进行，直至基学习器数目达到实现指定的值T，或整个集成结果达到退出条件
• 然后将这些学习器进行加权结合。

AdaBoost
AdaBoost是Boosting中的经典算法，其主要应用于二分类问题。
Adaboost 算法采用调整样本权重的方式来对样本分布进行调整，即提高前一轮个体学习器错误分类的样本的权重，而降低那些正确分类的样本的权重，这样就能使得错误分类的样本可以受到更多的关注，从而在下一轮中可以正确分类，使得分类问题被一系列的弱分类器“分而治之”。对于组合方式，AdaBoost采用加权多数表决的方法，具体地，加大分类误差率小的若分类器的权值，减小分类误差率大的若分类器的权值，从而调整他们在表决中的作用。
其算法流程
AdaBoost算法流程如下：

图5.AdaBoost算法流程
Bagging
Bagging是一种个体学习器之间不存在强依赖关系、可同时生成的并行式集成学习方法。
bagging基于自助采样法(bootstrap sampling)，也叫又放回重采样法。即给定包含m个样本的数据集，先随机从样本中取出一个样本放入采样集中，再把该样本返回初始数据集，使得下次采样时该样本仍可以被选中，这样，经过m次随机采样操作，就可以得到包含m个样本的采样集，初始数据集中有的样本多次出现，有的则未出现，其中，初始训练集中约有63.2%的样本出现在采样集中。照上面的方式进行T次操作，采样出T个含有m个训练集的采样集，然后基于每个采样集训练出T个基学习器，再将这些基学习器进行结合，即可得到集成学习器。在对输出进行预测时，Bagging通常对分类进行简单投票法，对回归使用简单平均法。若出现形同，则任选其一

图6.bagging算法流程
随机森林
随机森林(Random Forest，简称RF)是Bagging集成学习方法的一个扩展变体。随机森林以决策树作为Bagging集成学习的基学习器，与经典的决策树不同，随机森林在构建决策树模型的时候不是在所有的属性上去选择最优划分属性，而是在数据集属性的一个随机子集上进行最优划分属性的选择。由于基学习器的训练数据以及特征属性都不完全相同，随机森林构造的基学习器具有较大的差异，使得随机森林不仅简单、计算开销小，而且在很多实际任务中展现出强大的性能。

三、实验任务及步骤

如今越来越多的人在消费时使用信用卡进行支付，各大银行纷纷投入更多资源拓展信用卡业务，信用卡产业飞速发展。因为市场竞争激烈，信用卡产品同质化严重，商业银行迫切需要更有效的方式扩大客户规模，实现精准营销，从而降低陈本，提高效益。此次实践任务要求根据1000条信用卡营销的客户数据(详见“信用卡精准营销模型.csv”)，使用本章实现的AdaBoost和随机森林算法，构建信用卡精准营销模型。
代码理解：
np.ones 返回一个全为一的数组
np.multiply 数组和矩阵对应位置相乘，输出与相乘数组/矩阵的大小一致
np.exp（x） e的x次方
AdaBoost
操作步骤：
1）数据处理：前四列属性作为训练数据集，最后一列为标签，其中训练数据集中按9:1划分训练集和测试集。
2）函数补全：

3）结果分析：
以最后10%的数据来预测

这是取11个分类器的预测结果，其中有87个标签预测正确，通过不断额尝试，我发现当分类器的数量太少时预测效果不好，大概预测正确在60个左右，当分类器的数量在10个左右时效果最好，能预测正确85个左右，当分类器的数量太多时，效果会下降。
随机森林
操作步骤：
1）数据处理：读入数据集，然后按9:1划分训练集和测试集，然后将数据集的前五列最为训练样本，最后一列为标签，同时将dataframe类型转换为array类型。
2）函数补全：

3）结果分析：

一共100个预测结果，其中预测正确的有88个，这是我选择的结果比较好的例子，通过不断的改变森林中决策树的个数，每次选取的特征个数，树的最大高度可以得到不同的结果，我选择决策树的个数为4，每次选取特征的个数为5，树的最大高度为6，这时效果较好。

四、实验总结

在本次实验中，我学会了numpy库中的一些函数，同时也学会了将数学表达式转换成代码，理解了随机森林和AdaBoost的相关内容。但在实验过程中也遇到了很多问题，大部分集中在输入的数据格式不对，我通过上网查询资料和询问老师的方式解决了这些问题，在思考解决问题的过程中，自己的思维方式发生了改变，解决问题的能力也得到了提升。

1 联邦学习背景

鉴于数据隐私的重要性，国内外对于数据的保护意识逐步加强。2018年欧盟发布了《通用数据保护条例》（GDPR），我国国家互联网信息办公室起草的《数据安全管理办法(征求意见稿)》因此数据在安全合规的前提下自由流动，成了大势所趋。这些法律法规的出台，不同程度的对人工智能传统处理数据的方式提出更多的挑战。

AI高度发展的今天，多维度高质量的数据是制约其进一步发展的瓶颈。随着各个组织对于数据的重视程度的不断提升，跨组织以及组织内部不同部门之间的数据合作将变得越来越谨慎，造成了数据大量的以孤岛的形式存在

联邦学习的本质是基于数据隐私保护一种分布式机器学习技术或机器学习框架。它的目标是在保证数据隐私安全及合法合规的基础上，在模型无损的前提实现共同建模，提升AI模型的效果，进行业务的赋能。

那么既然是建模，在工业界最近若干年比较出名的大致可以分为GBDT和神经网络了，但是由于联邦学习的特性，需要对用户的特征与Label进行隐私安全保护，所以需要采用同态加密、秘钥分享、差分隐私等隐私计算手段保障安全。但是基于此带来了比较大的挑战，神经网络的复杂运算，指数、对数等会给建模提出非常大的难题，以目前的硬件与软件加密技术还是非常困难的，但是对于SecureBoost来说，只需要进行简单的同态运算就解决，达到和Xgboost同样的建模效果，所以本篇文章会和大家分享下联邦学习的安全树模型-Secure Boost。

BTW，目前神经网络虽然比较难做安全屏障，无法很好的做到计算性能与模型性能的Balance，但是经过笔者长期的思考，已经有了一个自己认为靠谱的方案，后续会逐步验证，如果最终验证靠谱，会和大家Share出来一起分享。

由于树模型相对来说知识较多，所以无法一步到位解决清晰SecureBoost，故本文章分成以下主题来进行，主要的脉络就是：决策树 -> 集成方法Bagging & Boosting -> GBDT -> XGBoost -> Secure Boost Tree。希望读者可以通过这一系列文章，对联邦学习的SecureBoost方法有一个整体的全方位的掌握。

其实，对于树模型系列来说，笔者以前做算法的时候，也在大量的使用，并且觉得自己是理解到位的，但是在我写联邦学习安全树模型的时候，发现很多的地方并没有理解透彻，有很多细节是没有考虑到的，写着写着就会发现自己的理论厚度不够，细节没有吃透。后来也花了大量的精力和时间去充电，这个事情也让我明白了，很多东西你看起来懂了，其实并没有懂，只有去真正的用心的去做过一遍，你才有些懂了，无论做什么事情脚踏实地才是最重要的。

2 联邦学习树模型方案

众所周知，在机器学习的前期，当深度学习没有大方异彩的时候，基本是LR、Xgboost的天下，在搜广推的场景中，基本上都可以看到Xboost的身影，基本可以说一个Xgb能用的明白，就可以在工业界占据一个位置。同时在Kaggle竞赛中，Xgb也是经常作为黑马出现。

万事万物都不是作为孤立的存在，所以针对联邦学习而言，联邦学习本质是基于隐私安全的分布式的建模，所以既要做安全的Xgb与LR等传统机器学习模型，也要做安全的深度模型。本系列文章主要介绍安全的树模型系列，计划出三章，基于上一章介绍了《联邦学习-安全树模型 SecureBoost之Desicion Tree》基础内容后，本章会继续介绍集成学习以及GBDT，关于Xgboost与联邦安全树模型会在下个章节进行描述。

SecureBoost属于Ensemble Learning集成学习的范畴，属于Boosting方法，基于残差去训练模型来拟合真实数据场景，非隐私计算的实现方式还有Xgboost、LightGBM、HistGradientBoostingClassifier等，不过过渡到这些集成学习算法之前，需要先介绍下GBDT。

3 Ensemble Learning

3.1 集成学习

集成学习(Ensemble Learning)是一种非常行之有效，并且在工业界大放异彩的机器学习方法。它本身不是一个单独的机器学习算法，而是通过构建并结合多个机器学习器来完成学习任务。也就是我们常说的“博采众长”、“三个臭皮匠顶个诸葛亮”，综合多家之长，集体的智慧，一起来解决复杂的问题，有点类似于社会中的参谋部与智囊团、智库。

集成学习可以用于分类问题，回归问题，特征选取，异常点检测等等，可以说所有的机器学习领域都可以看到集成学习的身影，在整个机器学习的演进史上承担的重要的作用，留下了浓厚的一笔，在工业界更是充当救火队员的角色，在Kaggle等国际比赛中，更是充当黑马的存在。在这里插入代码片

集成学习主要分为两种模式，Bagging与Boosting模式，这两种模式的区别主要是，弱学习器的组合方式，由于树模型是比较有效的机器学习模型，所以集成学习里面与树模型的结合非常紧密，将Bagging和Boosting分别和树模型结合分别生成：

• Bagging + 决策树=随机森林
• Boosting + 决策树=GBDT
• Boosting + 二阶可导Loss函数 = Xgboost

3.2 Bagging & Boosting

机器学习里面有两个非常重要的基础概念：Variance与Bias，就是方差与偏差，用来衡量模型，但是他们两个本身其实是矛盾的，Bagging与Boosting分布针对Variance与Bias进行探索。
bagging 的重点在于获得一个方差更小的集成模型，而 boosting则将主要生成偏差更小的集成模型（即使方差也可以被减小）。

3.2.1 Bagging (bootstrap aggregating)

Bagging即套袋法，通过并行的计算多个弱学习器，然后将多个弱学习器的结果进行投票或者均值等粗略，进行融合凝练，表征模型的判断。

1. 从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）。共进行k轮抽取，得到k个训练集。（k个训练集之间是相互独立的）
2. 每次使用一个训练集得到一个模型，k个训练集共得到k个模型。K个模型相互独立，没有依赖关系。
3. 集体智慧生成最终模型：
   • 对分类问题：针对K个模型的结果，采用投票的方式得到分类结果；
   • 对回归问题，针对K个模型的结果，计算数学期望作为最后的结果。

3.2.2 Boosting

其主要思想是将弱学习器组装成一个强学习器，并且通过一些列的顺序迭代过程，通过弱学习器的迭代组合，调整关键样本权重，训练出一组弱分类器，进行模型的迭代。

关于Boosting的两个核心问题：

1. 如何改变训练数据的概率分布与样本权重？

通过提高那些在前一轮被弱学习器判断错误的样例的权值，减小前一轮判断准确的样本权值，达到对错误信息的纠正的目标，亦或者通过学习残差的方式进行拟合。

2. 如何组合弱分类器？

通过加法模型将弱分类器进行线性组合，比如AdaBoost通过加权多数表决的方式，即增大错误率小的分类器的权值，同时减小错误率较大的分类器的权值吗，亦或GBDT的基于残差的加法模型组合，通过拟合残差的方式逐步减小残差，将每一步生成的模型叠加得到最终模型。

3.2.3 Bagging，Boosting二者之间的区别

Bagging和Boosting的区别主要有以下三点：

1. 样本选择上：

   • Bagging：采取Bootstraping的是随机有放回的取样，从原始集中选出的各轮训练集之间是独立的。
   • Boosting：Boosting的每一轮训练的样本是固定的，改变的是每个样本的权重。而权值是根据上一轮的计算结果进行调整。

2. 样例权重：

   • Bagging：采取的是均匀取样，每个样本的权重相同。
   • Boosting：根据错误率调整样本权重，错误率越大的样本权重越大。

3. 训练推理：

   • Bagging：各个弱学习器权值相同，并且各个弱学习器可以并行计算。
   • Boosting：各个弱学习器都有相应的权重，对于拟合的更好的分类器有较大的权重，并且各个弱学习器需要顺序迭代计算。

4 GBDT

其实很多人对于GBDT和Xgboost是分不清的，笔者最爱做的事情就是问很多面试者一个问题就是GDBT和Xgboost的区别。实际上这不是一个多么难的问题，上网一搜一个大把，从性能角度啊，一阶导数与二阶导数的区别啊。但是对于最本质的缺没有说清楚，所以说我们可以去网上查些资料，但是对于这些从网上获取的资料，要自己去甄别下，去提炼下，做到自己的融会贯通。

4.1 GDBT定义

下面给出定义：GBDT (Gradient Boosting Decision Tree) 梯度提升迭代决策树，是Boosting算法的一种。约束条件：

• GBDT使用的弱学习器必须是CART，且必须是回归树。
• GBDT用来做回归预测，当然也可以通过阈值的方式进行分类，不过主要是进行回归预测。

所以大家一定要记住，GBDT的弱学习器一定只能是CART树，一般是基于MSE的Loss利用最小二乘法计算一阶梯度。而Xgb的弱学习器非常灵活，一般只要求具备二阶导数就可以了。所以很多把GBDT和Xgb的概念混淆，或者只说一阶导与二阶导的区别，都是太片面的。

4.2 GBDT推导过程

GBDT的每次计算都是为了减少上次计算的残差，那么一个比较朴素的想法就是我们在残差的方向上减少梯度，进而建立新的学习器是不是就可以了呢？不错，GBDT就是这么来的。

1. 首先，假设数据集是$(x_1,y_1),(x_2,y_2),...,(x_n,y_n)$，模型是$F(x)$，去拟合这些数据。那么残差的定义是$y_i-F(x_i)$，定义本模型未拟合的部分。
2. 接着，假设损失函数定义MSE（回归问题的Loss Function），那么损失函数的定义是$\frac{1}{2}{\sum }_0^n(y_i-F(x_i){)}^2$。
3. 然后，针对损失函数进行推导$$L(y,F(x))=\frac{1}{2}\sum _0^n(y_i-F(x_i){)}^2$$，然后对损失函数进行一阶求导，$$\frac{\partial L}{\partial F(x)}=\frac{\partial L(y,F(x_i))}{\partial F(x_i)}=F(x_i)-y_i$$
4. 然后，通过如上公式可以推导，残差与负的梯度方向相同。验证完毕。
5. 所以，GBDT的分裂节点可以根据各个特征的梯度大小来进行选取。

5 番外篇

个人介绍：杜宝坤，隐私计算行业从业者，从0到1带领团队构建了京东的联邦学习解决方案9N-FL，同时主导了联邦学习框架与联邦开门红业务。
框架层面：实现了电商营销领域支持超大规模的工业化联邦学习解决方案，支持超大规模样本PSI隐私对齐、安全的树模型与神经网络模型等众多模型支持。
业务层面：实现了业务侧的开门红业务落地，开创了新的业务增长点，产生了显著的业务经济效益。
个人比较喜欢学习新东西，乐于钻研技术。基于从全链路思考与决策技术规划的考量，研究的领域比较多，从工程架构、大数据到机器学习算法与算法框架均有涉及。欢迎喜欢技术的同学和我交流，邮箱：baokun06@163.com