[Hands On ML] 7. 集成学习和随机森林

本文为《机器学习实战：基于Scikit-Learn和TensorFlow》的读书笔记。
中文翻译参考

《统计学习方法》提升方法（Boosting）笔记

集成学习：集体的智慧大于个人

1. 投票分类

使用不同的算法得到不同的分类器

from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
X, y = make_moons(n_samples=100,shuffle=True, noise=10)
# help(train_test_split)
X_train, X_test, y_train, y_test = train_test_split(X,y)

from sklearn.ensemble import RandomForestClassifier 
from sklearn.ensemble import VotingClassifier 
from sklearn.linear_model import LogisticRegression 
from sklearn.svm import SVC
log_clf = LogisticRegression() 
rnd_clf = RandomForestClassifier() 
svm_clf = SVC()
voting_clf = VotingClassifier(estimators=[('lr', log_clf), ('rf', rnd_clf), 
                                          ('svc', svm_clf)], voting='hard') 
voting_clf.fit(X_train, y_train)

from sklearn.metrics import accuracy_score 
for clf in (log_clf, rnd_clf, svm_clf, voting_clf): 
    clf.fit(X_train, y_train)
    y_pred = clf.predict(X_test) 
    print(clf.__class__.__name__, accuracy_score(y_test, y_pred)) 

• 投票分类器比大部分单独的分类表现好些

LogisticRegression 0.68
RandomForestClassifier 0.52
SVC 0.56
VotingClassifier 0.6

2. Bagging、Pasting

对每个分类器使用相同的训练算法（在不同的训练集上训练）

• 有放回采样被称为装袋（Bagging，是 bootstrap aggregating 的缩写），可进行多次采样
• 无放回采样称为粘贴（pasting）

所有的分类器被训练后，集成通过对所有分类器结果的简单聚合来预测

• 聚合降低了偏差和方差，比在原始训练集上的单一分类器更小的方差

from sklearn.ensemble import BaggingClassifier 
from sklearn.tree import DecisionTreeClassifier
bag_clf = BaggingClassifier(DecisionTreeClassifier(), n_estimators=500,        
  			max_samples=100, bootstrap=True, n_jobs=-1) 
bag_clf.fit(X_train, y_train) 
y_pred = bag_clf.predict(X_test)

采用集成方法的决策树分类效果更好

3. Out of Bag 评价

bagging 中有放回采用中，总有些是从未被采到的，可以用来做效果评估

from sklearn.ensemble import BaggingClassifier 
from sklearn.tree import DecisionTreeClassifier
bag_clf = BaggingClassifier(DecisionTreeClassifier(), n_estimators=500,bootstrap=True, n_jobs=-1, oob_score=True)
bag_clf.fit(X_train, y_train) 
bag_clf.oob_score_ # oob集的预测准确率
bag_clf.oob_decision_function_ # 每个oob实例的决策概率

4. 随机贴片与随机子空间

BaggingClassifier也支持采样特征

• 由超参数max_features和bootstrap_features控制
• 工作方式和max_samples和bootstrap一样，但这是对于特征采样而不是实例采样

在处理高维度输入下（例如图片）此方法尤其有效

• 对训练实例和特征都采样被叫做随机贴片
• 保留所有的训练实例（例如bootstrap=False和max_samples=1.0），仅对特征采样（bootstrap_features=True并且/或者max_features小于 1.0）叫做随机子空间

采样特征 导致 更多的预测多样性，用高偏差换低方差

5. 随机森林

• 决策树的一种集成（通常是bagging，有时是pasting 进行训练）

from sklearn.ensemble import RandomForestClassifier
rnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1) 
rnd_clf.fit(X_train, y_train)
y_pred_rf = rnd_clf.predict(X_test)

• 参数为：决策树参数（控制树的生长）+ bagging_clf 集成的参数（控制集成）

• 随机森林算法在 树生长时 引入了 额外的随机

• 与在节点分裂时需要找到最好分裂特征相反（详见第六章），它在一个随机的特征集中找最好的特征。它导致了树的差异性，并且再一次用高偏差换低方差，总的来说是一个更好的模型

以下 bagging 大致相当于 随机森林

bag_clf = BaggingClassifier(DecisionTreeClassifier(splitter="random", max_leaf_nodes=16),n_estimators=500, max_samples=1.0, bootstrap=True, n_jobs=-1)

6. 极端随机树 Extra-Trees

在随机森林上生长树时，在每个结点分裂时只考虑随机特征集上的特征。

• 极端随机树（Extremely Randomized
  Trees），不找最佳的特征阈值，它使用随机阈值使树更加随机
• 所以，它训练起来比随机森林更快

ExtraTreesClassifier
ExtraTreesRegressor

到底是 随机森林好，还是极端随机树好，交叉验证比较

7. 特征重要程度

• 靠近树根的特征更重要
• 一个特征在森林的全部树中出现的平均深度来预测特征的重要性

from sklearn.datasets import load_iris 
iris = load_iris() 
rnd_clf = RandomForestClassifier(n_estimators=500, n_jobs=-1) 
rnd_clf.fit(iris["data"], iris["target"]) 
for name, score in zip(iris["feature_names"], rnd_clf.feature_importances_): 
     print(name, score) 
sepal length (cm) 0.112492250999
sepal width (cm) 0.0231192882825 
petal length (cm) 0.441030464364 
petal width (cm) 0.423357996355 

鸢尾花四个特征的重要度

• 随机森林可以快速了解特征重要度，可以进行特征筛选

8. 提升方法

将几个弱学习者组合成强学习者的集成方法

8.1 AdaBoost

• 使一个新的分类器去修正之前分类结果的方法：对之前分类结果不对的训练实例多加关注
  
  
  AdaBoost 迭代过程

序列学习 技术的一个重要的缺点就是：它不能被并行化（只能按步骤）

• 每个分类器只能在之前的分类器已经被训练和评价后再进行训练
• 因此，它不像Bagging和Pasting一样

---

• sklearn 通常使用 Adaboost 的多分类版本 SAMME（这就代表了 分段加建模使用多类指数损失函数）
• 如果只有两类别，那么 SAMME 是与 Adaboost 相同的
• 如果分类器可以预测类别概率（例如如果它们有predict_proba()），sklearn 可以使用 SAMME.R（R 代表“REAL”）的版本，预测概率通常比预测分类更好

一个决策树桩是max_depth=1的决策树，一个单一决策节点+两个叶子结点。这就是AdaBoostClassifier的默认基分类器：

from sklearn.ensemble import AdaBoostClassifier
ada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1), n_estimators=200,algorithm="SAMME.R", learning_rate=0.5) 
ada_clf.fit(X_train, y_train)

• Adaboost 集成过拟合了训练集，可以减少基分类器的数量 或者 对基分类器使用更强的正则化

8.2 梯度提升

不像 Adaboost 那样每一次迭代都更改实例的权重，这个方法是去使用新的分类器去拟合前面分类器预测的残差

from sklearn.tree import DecisionTreeRegressor 
tree_reg1 = DecisionTreeRegressor(max_depth=2) 
tree_reg1.fit(X, y) 

现在在第一个分类器的残差上训练第二个分类器：

y2 = y - tree_reg1.predict(X) 
tree_reg2 = DecisionTreeRegressor(max_depth=2) 
tree_reg2.fit(X, y2) 

随后在第二个分类器的残差上训练第三个分类器：

y3 = y2 - tree_reg1.predict(X) 
tree_reg3 = DecisionTreeRegressor(max_depth=2) 
tree_reg3.fit(X, y3) 

通过集成所有树的预测来在一个新的实例上进行预测

y_pred = sum(tree.predict(X_new) for tree in (tree_reg1, tree_reg2, tree_reg3)) 

sklearn 内置 GBRT

from sklearn.ensemble import GradientBoostingRegressor
gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=3, learning_rate=1.0) 
gbrt.fit(X, y)

超参数learning_rate 确立了每个树的贡献

• 设置为很小的数，在集成中就需要更多的树去拟合训练集，但预测通常会更好。这个正则化技术叫做 shrinkage。
• 下图展示了，两个在低学习率上训练的 GBRT 集成：左面是一个没有足够树去拟合训练集的树，右面是有过多的树过拟合训练集的树

• 寻找最优的tree的数量：早停技术（第四章），使用staged_predict()

import numpy as np 
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

X_train, X_val, y_train, y_val = train_test_split(X, y)
gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=120) 
gbrt.fit(X_train, y_train)
errors = [mean_squared_error(y_val, y_pred)         
     for y_pred in gbrt.staged_predict(X_val)] 
     				# 阶段性的预测，迭代一次预测一次
bst_n_estimators = np.argmin(errors)
# 最好的树的个数
gbrt_best = GradientBoostingRegressor(max_depth=2,n_estimators=bst_n_estimators) 
gbrt_best.fit(X_train, y_train) 

• 使用 warn_start = True，保留之前的预测，增量训练，不用重头开始
• 当误差超过给定次数没有得到改善，停止训练

sklearn中warm_start参数的作用详解

• GradientBoostingRegressor也支持指定用于训练每棵树的样本比例subsample。如果subsample=0.25，那么每个树都会在 25% 随机选择的训练实例上训练。

• 这也是个高偏差换低方差的作用。它同样也加速了训练。这个技术叫做随机梯度提升

8.3 Stacking

Stacking（stacked generalization 的缩写）。
思想：不使用琐碎的函数（如硬投票）来聚合集合中所有分类器的预测，
使用一个新的分类器模型，对所有的预测结果作为输入，预测输出最终结果

sklearn 暂不直接支持 stacking