机器学习----集成学习(Ensemble Learning)

集成学习(Ensemble Learning)

什么是集成学习

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

机器学习的两个核心任务

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

大白话集成学习: 多种机器学习算法都能做同样的事情。让不同的算法针对同一个数据都跑一遍，最终使用投票的方法，少数服从多数，用多数投票的结果作为最终的结果。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)
plt.scatter(X[y==0,0],X[y==0,1])
plt.scatter(X[y==1,0],X[y==1,1])
plt.show()

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

自己实现集成学习

• 逻辑回归

from sklearn.linear_model import LogisticRegression
log_clf = LogisticRegression()
log_clf.fit(X_train, y_train)
log_clf.score(X_test, y_test)

0.864

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

• SVM

from sklearn.svm import SVC
svm_clf = SVC()
svm_clf.fit(X_train, y_train)
svm_clf.score(X_test, y_test)

0.896

• 决策树

from sklearn.tree import DecisionTreeClassifier
dt_clf = DecisionTreeClassifier()
dt_clf.fit(X_train, y_train)
dt_clf.score(X_test, y_test)

0.856

y_predict1 = log_clf.predict(X_test)
y_predict2 = svm_clf.predict(X_test)
y_predict3 = dt_clf.predict(X_test)
y_predict = y_predict1 + y_predict2 + y_predict3
y_predict

array([2, 0, 1, 3, 3, 2, 0, 0, 0, 0, 3, 0, 3, 3, 3, 0, 0, 3, 2, 0, 0, 3,
2, 0, 0, 0, 3, 0, 3, 0, 3, 3, 1, 0, 3, 1, 0, 3, 3, 3, 1, 3, 1, 1,
0, 0, 2, 1, 3, 1, 2, 3, 0, 0, 1, 0, 2, 3, 0, 3, 0, 3, 3, 0, 3, 0,
0, 1, 0, 3, 0, 0, 3, 2, 0, 0, 3, 3, 0, 0, 3, 2, 2, 1, 3, 2, 2, 0,
3, 3, 3, 0, 0, 0, 0, 3, 0, 1, 1, 3, 0, 3, 3, 0, 0, 0, 0, 0, 2, 3,
1, 0, 0, 2, 1, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0])

y_predict = np.array((y_predict1 + y_predict2 + y_predict3)>=2, dtype='int')
y_predict

array([1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0,
0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,
0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0,
1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1,
0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0])

from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_predict)

0.912

• sklern中提供类似pipline的方式

使用VotingClassifier

from sklearn.ensemble import VotingClassifier
voteting_clf = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()),
    ('svm_clf', SVC()),
    ('dt_clf', DecisionTreeClassifier(random_state=666)),
], voting='hard')
voteting_clf.fit(X_train, y_train)
voteting_clf.score(X_test, y_test)

0.904

Soft Voting Classifier

hard voting计算投票的方式是直接按照投票数量得出的
soft voting 计算投票考虑了权重
假如一个二分类问题，5个模型分别对一个样本进行分类。以下是每个模型认为每种分类的概率：

按照hard voting，投票结果为A为2票,B为3票, 最终结果为A
但考虑上每种类的概率

投票结果为A



逻辑回归，KNN，决策树（叶子结点的每个类的比例），都能估计概率。
SVM本身没有考虑概率，因为它是计算margin。但SVM可以有一种方法来计算概率SVC(probability=True)

• Hard

from sklearn.ensemble import VotingClassifier
voteting_clf = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()),
    ('svm_clf', SVC()),
    ('dt_clf', DecisionTreeClassifier(random_state=666)),
], voting='hard')
voteting_clf.fit(X_train, y_train)
voteting_clf.score(X_test, y_test)

0.896

• Soft

from sklearn.ensemble import VotingClassifier
voteting_clf2 = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()),
    ('svm_clf', SVC(probability = True)),
    ('dt_clf', DecisionTreeClassifier(random_state=666)),
], voting='soft')
voteting_clf2.fit(X_train, y_train)
voteting_clf2.score(X_test, y_test)

0.912

Bagging 和 Pasting

虽然有很多机器学习的算法，但从投票的角度看，仍然不够多创建更多的子模型，集成更多子模型的意见
子模型之间不能一致，子模型之间要有差异性, 如何创建差异性？
解决方法：
每个子模型只看样本数据的一部分。
每个子模型不太需要太高的准确率。只要子模型足够多，准确率就会提高。
例如500个子模型，每个子模型的准确率是60%，最终准确率能达到99.9%

Bagging集成原理

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

实现过程：

1. 采样不同数据集
   
   2)训练分类器
   
   3)平权投票，获取最终结果
   
   4)主要实现过程小结

取样方法：

• 放回取样 bagging（bootstrap）
• 不放回取样 pasting

bagging更常用，优点：

• 没有那么依赖随机
• 数据量要求没那么高

使用 Bagging

• 决策树这种非参数的算法更容易产生差异较大的子模型
• 所有集成学习如果要集成成百上千个子模型，通常首先决策树
• n_estimators：子模型数
• max_samples：每个子模型看的样本树
• bootstrap：放回取样

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                                n_estimators=10, max_samples=100,
                                bootstrap=True)
bagging_clf.fit(X_train, y_train)
bagging_clf.score(X_test, y_test)

0.888

bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                                n_estimators=10000, max_samples=100,
                                bootstrap=True)
bagging_clf.fit(X_train, y_train)
bagging_clf.score(X_test, y_test)

0.912

随机森林

• Bagging
  Base Estimator: Decision Tree
  只要是以决策树为基础的集成学习算法都叫随机森林。
  scikit-learn提供了随机森林算法，并为算法提供了更多的随机性。
  sickit-learn中，决策树在节点上划分，在随机的特征子集上寻找最优划分的特征。

随机森林构造过程

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

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

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

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

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

随机森林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。

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

1. 最大特征数max_features
2. 最大深度max_depth
3. 内部节点再划分所需最小样本数min_samples_split
4. 叶子节点最少样本数min_samples_leaf。

bagging集成优点

​ Bagging + 决策树/线性回归/逻辑回归/深度学习… = bagging集成学习方法
经过上面方式组成的集成学习方法:

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

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

首先简单说一下什么是袋外样本oob (Out of bag)：在随机森林中，m个训练样本会通过bootstrap (有放回的随机抽样) 的抽样方式进行T次抽样每次抽样产生样本数为m的采样集，进入到并行的T个决策树中。这样有放回的抽样方式会导致有部分训练集中的样本(约36.8%)未进入决策树的采样集中，而这部分未被采集的的样本就是袋外数据oob, 而这个袋外数据就可以用来检测模型的泛化能力，和交叉验证类似。可以理解成从train datasets 中分出来的validation datasets。
随机森林的 Bagging 过程，对于每一颗训练出的决策树 gt ，与数据集 D 有如下关系：

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

由于基分类器是构建在训练样本的自助抽样集上的，只有约 63.2％ 原样本集出现在中，而剩余的 36.8％ 的数据作为包外数据，可以用于基分类器的验证集。 经验证，包外估计是对集成分类器泛化误差的无偏估计.

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

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

什么是oob_score

对于单棵用采样集训练完成的决策树Ti，用袋外数据运行后会产生一个oob_score (返回的是R square来判断)，对每一棵决策树都重复上述操作，最终会得到T个oob_score，把这T和oob_score平均，最终得到的就是整个随机森林的oob_score

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=666)
plt.scatter(X[y==0,0],X[y==0,1])
plt.scatter(X[y==1,0],X[y==1,1])
plt.show()

from sklearn.ensemble import RandomForestClassifier
rf_clf = RandomForestClassifier(n_estimators=500, oob_score=True, random_state=666, n_jobs=-1)
rf_clf.fit(X, y)
rf_clf.oob_score_

0.892

# 随机森林拥有决策树和BaggingClassifier的所有参数：）

rf_clf2 = RandomForestClassifier(n_estimators=500,max_leaf_nodes=16, oob_score=True, random_state=666, n_jobs=-1)
rf_clf2.fit(X, y)
rf_clf2.oob_score_

0.906

Kaggle实战

https://www.kaggle.com/c/otto-group-product-classification-challenge/overview
奥托集团是世界上最大的电子商务公司之一，在20多个国家设有子公司。该公司每天都在世界各地销售数百万种产品,所以对其产品根据性能合理的分类非常重要。不过,在实际工作中,工作人员发现,许多相同的产品得到了不同的分类。本案例要求,你对奥拓集团的产品进行正确的分类。尽可能的提供分类的准确性。
![在这里插入图片描述](https://img-blog.csdnimg.cn/8f195558c6ad4563bc19ab825a362c11.png

数据集介绍

• 本案例中，数据集包含大约200,000种产品的93个特征。

• 其目的是建立一个能够区分otto公司主要产品类别的预测模型

• 所有产品共被分成九个类别（例如时装，电子产品等）。

  

• id - 产品id

• feat_1, feat_2, …, feat_93 - 产品的各个特征

• target - 产品被划分的类别

评分标准

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

Boosting

什么是boosting: 随着学习的积累从弱到强

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

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

实现过程：
训练第一个学习器

2.调整数据分布
将错误的数据权重变的高一些, 正确的变得小一些

3.训练第二个学习器

4.再次调整数据分布

5.依次训练学习器，调整数据分布

6.整体过程实现

前面的一类集成学习的思路(voting)：独立地集成多个模型，让各种子模型在视角上有差异化，并最终综合这些子模型的结果，获得学习的最终结果。
另一类集成学习的思路叫做boosting。boosting即增强的意思。boosting也要集成多个模型，但每个模型都在尝试增强(boosting)整体的效果。子模型之间不是独立的关系。

原始数据集1 --某个算法1–> 某个模型1
模型1没有很好学习的点的权值增大，很好学习到的点的权值减小，得到数据集2 --某个算法2 --> 某个模型2
。。。
每一个子模型都在推动上一个子模型犯的错误, 用这些子模型投票得到最终结果

bagging集成与boosting集成的区别：

1. 区别一:数据方面

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

2. 区别二:投票方面

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

3. 区别三:学习顺序

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

4. 区别四:主要作用

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

AdaBoosting

步骤一 ：初始化训练数据权重相等，训练第一个学习器。

该假设每个训练样本在基分类器的学习中作用相同，这一假设可以保证第一步能够在原始数据上学习基本分类器H1(x)H_1(x)H​1​​(x)
步骤二 ：AdaBoost反复学习基本分类器，在每一轮m=1,2,…,M顺次的执行下列操作：

步骤三 ：对m个学习器进行加权投票

案例

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

步骤一：初始化训练数据权重相等，训练第一个学习器：

步骤二：AdaBoost反复学习基本分类器，在每一轮m=1,2,…,Mm=1,2,…,Mm=1,2,…,M顺次的执行下列操作：

当m=1的时候：

当m=2的时候：

当m=3的时候：

步骤三：对m个学习器进行加权投票,获取最终分类器

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=666)
plt.scatter(X[y==0,0],X[y==0,1])
plt.scatter(X[y==1,0],X[y==1,1])
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=666)
ada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2), n_estimators=500)
ada_clf.fit(X_train, y_train)
ada_clf.score(X_test, y_test)

0.832

GBDT

GBDT 的全称是 Gradient Boosting Decision Tree，梯度提升树，在传统机器学习算法中，GBDT算的上TOP3的算法。

训练一个模型m1，产生错误e1
针对e1训练第二个模型m2，产生错误e2
针对e2训练第三个模型m3，产生错误e3
。。。
最终预测结果是m1+m2+m3+…

from sklearn.ensemble import GradientBoostingClassifier
GBDT = GradientBoostingClassifier(max_depth=2, n_estimators=30)
GBDT.fit(X_train, y_train)
GBDT.score(X_test, y_test)

0.848
想要理解GBDT的真正意义，那就必须理解GBDT中的Gradient Boosting 和Decision Tree分别是什么

Decision Tree：CART回归树

首先，GBDT使用的决策树是CART回归树，无论是处理回归问题还是二分类以及多分类，GBDT使用的决策树通通都是都是CART回归树。
为什么不用CART分类树呢？ 因为GBDT每次迭代要拟合的是梯度值，是连续值所以要用回归树。
对于回归树算法来说最重要的是寻找最佳的划分点，那么回归树中的可划分点包含了所有特征的所有可取的值。
在分类树中最佳划分点的判别标准是熵或者基尼系数，都是用纯度来衡量的，但是在回归树中的样本标签是连续数值，所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。

回归树生成算法

输入：训练数据集D:
输出：回归树 f(x)
在训练数据集所在的输入空间中，递归的将每个区域划分为两个子区域并决定每个子区域上的输出值，构建二叉决策树：

Gradient Boosting： 拟合负梯度

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

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

提升树算法：

上面伪代码中的残差是什么

回到我们上面讲的那个通俗易懂的例子中，第一次迭代的残差是10岁，第二 次残差4岁,

当损失函数是平方损失和指数损失函数时，梯度提升树每一步优化是很简单的，但是对于一般损失函数而言，往往每一步优化起来不那么容易。针对这一问题，Friedman提出了梯度提升树算法，这是利用最速下降的近似方法，其关键是利用损失函数的负梯度作为提升树算法中的残差的近似值。
那么负梯度长什么样呢？

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

那么对于分类问题呢？二分类和多分类的损失函数都是logloss。

GBDT算法原理