假設你去隨機問很多人一個很復雜的問題，然后把它們的答案合并起來。通常情況下你會發現這個合并的答案比一個專家的答案要好。這就叫做群體智慧。同樣的，如果你合并了一組分類器的預測（像分類或者回歸），你也會得到一個比單一分類器更好的預測結果。這一組分類器就叫做集成；因此，這個技術就叫做集成學習，一個集成學習算法就叫做集成方法。
例如，你可以訓練一組決策樹分類器，每一個都在一個隨機的訓練集上。為了去做預測，你必須得到所有單一樹的預測值，然后通過投票（例如第六章的練習）來預測類別。例如一種決策樹的集成就叫做隨機森林，它除了簡單之外也是現今存在的最強大的機器學習算法之一。
向我們在第二章討論的一樣，我們會在一個項目快結束的時候使用集成算法，一旦你建立了一些好的分類器，就把他們合并為一個更好的分類器。事實上，在機器學習競賽中獲得勝利的算法經常會包含一些集成方法。
在本章中我們會討論一下特別著名的集成方法，包括bagging,boosting,stacking，和其他一些算法。我們也會討論隨機森林。
1 投票分類
假設你已經訓練了一些分類器，每一個都有 80% 的準確率。你可能有了一個邏輯斯蒂回歸、或一個 SVM、或一個隨機森林，或者一個 KNN，或許還有更多（詳見圖 7-1）
一個非常簡單去創建一個更好的分類器的方法就是去整合每一個分類器的預測然后經過投票去預測分類。這種分類器就叫做硬投票分類器（詳見圖 7-2）。
令人驚奇的是這種投票分類器得出的結果經常會比集成中最好的一個分類器結果更好。事實上，即使每一個分類器都是一個弱學習器（意味著它們也就比瞎猜好點），集成后仍然是一個強學習器（高準確率），只要有足夠數量的弱學習者，他們就足夠多樣化。
這怎么可能？接下來的分析將幫助你解決這個疑問。假設你有一個有偏差的硬幣，他有 51% 的幾率為正面，49% 的幾率為背面。如果你實驗 1000 次，你會得到差不多 510 次正面，490 次背面，因此大多數都是正面。如果你用數學計算，你會發現在實驗 1000 次后，正面概率為 51% 的人比例為 75%。你實驗的次數越多，正面的比例越大（例如你試驗了 10000 次，總體比例可能性就會達到 97%）。這是因為大數定律：當你一直用硬幣實驗時，正面的比例會越來越接近 51%。圖 7-3 展示了始終有偏差的硬幣實驗。你可以看到當實驗次數上升時，正面的概率接近于 51%。最終所有 10 種實驗都會收斂到 51%，它們都大于 50%。
heads_proba = 0.51coin_tosses = (np.random.rand(10000, 10) < heads_proba).astype(np.int32)cumulative_heads_ratio = np.cumsum(coin_tosses, axis=0) / np.arange(1, 10001).reshape(-1, 1)# law_of_large_numbers_plotplt.figure(figsize=(8,3.5))plt.plot(cumulative_heads_ratio)plt.plot([0, 10000], [0.51, 0.51],"k--", linewidth=2, label="51%")plt.plot([0, 10000], [0.5, 0.5],"k-", label="50%")plt.xlabel("Number of coin tosses")plt.ylabel("Heads ratio")plt.legend(loc="lower right")plt.axis([0, 10000, 0.42, 0.58])plt.show()
同樣的，假設你創建了一個包含 1000 個分類器的集成模型，
其中每個分類器的正確率只有 51%（僅比瞎猜好一點點）。如果你用投票去預測類別，你可能得到 75% 的準確率！
然而，這僅僅在所有的分類器都獨立運行的很好、不會發生有相關性的錯誤的情況下才會這樣，然而每一個分類器都在同一個數據集上訓練，導致其很可能會發生這樣的錯誤。
他們可能會犯同一種錯誤，所以也會有很多票投給了錯誤類別導致集成的準確率下降。
如果使每一個分類器都獨立自主的分類，那么集成模型會工作的很好。去得到多樣的分類器的方法之一就是用完全不同的算法，這會使它們會做出不同種類的錯誤，這會提高集成的正確率
接下來的代碼創建和訓練了在sklearn中的投票分類器。這個分類器由三個不同的分類器組成：
fromsklearn.model_selectionimporttrain_test_splitfromsklearn.datasetsimportmake_moonsX, y = make_moons(n_samples=500, noise=0.30, random_state=42)X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
fromsklearn.ensembleimportRandomForestClassifierfromsklearn.ensembleimportVotingClassifierfromsklearn.linear_modelimportLogisticRegressionfromsklearn.svmimportSVClog_clf = LogisticRegression(random_state=42)rnd_clf = RandomForestClassifier(random_state=42)svm_clf = SVC(random_state=42)voting_clf = VotingClassifier(? ? estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],? ? voting='hard')
讓我們看一下在測試集上的準確率：
fromsklearn.metricsimportaccuracy_scoreforclfin(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))LogisticRegression0.864RandomForestClassifier0.872SVC0.888VotingClassifier0.896
你看！投票分類器比其他單獨的分類器表現的都要好。
# 軟投票log_clf = LogisticRegression(random_state=42)rnd_clf = RandomForestClassifier(random_state=42)svm_clf = SVC(probability=True, random_state=42)voting_clf = VotingClassifier(? ? estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],? ? voting='soft')voting_clf.fit(X_train, y_train)VotingClassifier(estimators=[('lr', LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,? ? ? ? ? intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,? ? ? ? ? penalty='l2', random_state=42, solver='liblinear', tol=0.0001,? ? ? ? ? verbose=0, warm_start=False)), ('rf', RandomFor...bf',
? max_iter=-1, probability=True, random_state=42, shrinking=True,
? tol=0.001, verbose=False))],
? ? ? ? flatten_transform=None, n_jobs=1, voting='soft', weights=None)
fromsklearn.metricsimportaccuracy_scoreforclfin(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))LogisticRegression0.864RandomForestClassifier0.872SVC0.888VotingClassifier0.912
如果所有的分類器都能夠預測類別的概率（例如他們有一個predict_proba()方法），那么你就可以讓sklearn以最高的類概率來預測這個類，平均在所有的分類器上。這種方式叫做軟投票。
他經常比硬投票表現的更好，因為它給予高自信的投票更大的權重。你可以通過把voting="hard"設置為voting="soft"來保證分類器可以預測類別概率。然而這不是 SVC 類的分類器默認的選項，所以你需要把它的probability hyperparameter設置為True（這會使SVC使用交叉驗證去預測類別概率，其降低了訓練速度，但會添加predict_proba()方法）。如果你修改了之前的代碼去使用軟投票，你會發現投票分類器正確率高達91%
2 Bagging 和 Pasting
換句話說，Bagging和Pasting都允許在多個分類器間對訓練集進行多次采樣。
Bagging可以通過使用不同的訓練算法去得到一些不同的分類器。
Pasting就是對每一個分類器都使用相同的訓練算法，但是在不同的訓練集上去訓練它們。
有放回采樣被稱為裝袋（Bagging，是bootstrap aggregating的縮寫）。
無放回采樣稱為粘貼（pasting）。
換句話說，Bagging和Pasting都允許在多個分類器上對訓練集進行多次采樣，但只有Bagging允許對同一種分類器上對訓練集進行進行多次采樣。采樣和訓練過程如圖7-4所示。
當所有的分類器被訓練后，集成可以通過對所有分類器結果的簡單聚合來對新的實例進行預測。聚合函數通常對分類是*統計模式*（例如硬投票分類器）或者對回歸是平均。每一個單獨的分類器在如果在原始訓練集上都是高偏差，但是聚合降低了偏差和方差。通常情況下，集成的結果是有一個相似的偏差，但是對比與在原始訓練集上的單一分類器來講有更小的方差。
正如你在圖 7-4 上所看到的，分類器可以通過不同的CPU 核或其他的服務器一起被訓練。相似的，分類器也可以一起被制作。這就是為什么 Bagging 和 Pasting 是如此流行的原因之一：它們的可擴展性很好。
2.1 在 sklearn 中的 Bagging 和 Pasting
sklearn為Bagging和Pasting提供了一個簡單的API：BaggingClassifier類（或者對于回歸可以是BaggingRegressor。接下來的代碼訓練了一個500個決策樹分類器的集成，每一個都是在數據集上有放回采樣100個訓練實例下進行訓練（這是Bagging的例子，如果你想嘗試Pasting，就設置bootstrap=False）。n_jobs參數告訴sklearn用于訓練和預測所需要CPU核的數量。（-1代表著sklearn會使用所有空閑核）：
fromsklearn.ensembleimportBaggingClassifierfromsklearn.treeimportDecisionTreeClassifierfromsklearn.metricsimportaccuracy_scorebag_clf = BaggingClassifier(? ? DecisionTreeClassifier(random_state=42), n_estimators=500,? ? max_samples=100, bootstrap=True, n_jobs=-1, random_state=42)bag_clf.fit(X_train, y_train)y_pred = bag_clf.predict(X_test)print(accuracy_score(y_test, y_pred))tree_clf = DecisionTreeClassifier(random_state=42)tree_clf.fit(X_train, y_train)y_pred_tree = tree_clf.predict(X_test)print(accuracy_score(y_test, y_pred_tree))0.9040.856
如果基分類器可以預測類別概率（例如它擁有predict_proba()方法），那么BaggingClassifier會自動的運行軟投票，這是決策樹分類器的情況。
圖 7-5 對比了單一決策樹的決策邊界和Bagging集成500個樹的決策邊界，兩者都在moons數據集上訓練。正如你所看到的，集成的分類比起單一決策樹的分類產生情況更好：集成有一個可比較的偏差但是有一個較小的方差（它在訓練集上的錯誤數目大致相同，但決策邊界較不規則）。
Bootstrap在每個預測器被訓練的子集中引入了更多的分集，所以Bagging結束時的偏差比Pasting更高，但這也意味著預測因子最終變得不相關，從而減少了集合的方差。總體而言，Bagging通常會導致更好的模型，這就解釋了為什么它通常是首選的。然而，如果你有空閑時間和CPU功率，可以使用交叉驗證來評估Bagging和Pasting哪一個更好。
2.2 Out-of-Bag 評價
對于Bagging來說，一些實例可能被一些分類器重復采樣，但其他的有可能不會被采樣。BaggingClassifier默認采樣。BaggingClassifier默認是有放回的采樣m個實例 （bootstrap=True），其中m是訓練集的大小，這意味著平均下來只有63%的訓練實例被每個分類器采樣，剩下的37%個沒有被采樣的訓練實例就叫做Out-of-Bag實例。注意對于每一個的分類器它們的37%不是相同的。
因為在訓練中分類器從來沒有看到過oob實例，所以它可以在這些實例上進行評估，而不需要單獨的驗證集或交叉驗證。你可以拿出每一個分類器的oob來評估集成本身。
在sklearn中，你可以在訓練后需要創建一個BaggingClassifier來自動評估時設置oob_score=True來自動評估。接下來的代碼展示了這個操作。評估結果通過變量oob_score_來顯示：
bag_clf = BaggingClassifier(? ? DecisionTreeClassifier(random_state=42), n_estimators=500,? ? bootstrap=True, n_jobs=-1, oob_score=True, random_state=40)bag_clf.fit(X_train, y_train)bag_clf.oob_score_0.90133333333333332
根據這個obb評估，BaggingClassifier可以再測試集上達到93.1%的準確率，讓我們修改一下：
fromsklearn.metricsimportaccuracy_scorey_pred = bag_clf.predict(X_test)accuracy_score(y_test, y_pred)0.91200000000000003
我們在測試集上得到了91.2%的準確率，足夠接近了！
對于每個訓練實例oob決策函數也可通過oob_decision_function_變量來展示。在這種情況下（當基決策器有predict_proba()時）決策函數會對每個訓練實例返回類別概率。例如，oob評估預測第二個訓練實例有60.6%的概率屬于正類（39.4%屬于負類）：
bag_clf.oob_decision_function_array([[0.31746032, 0.68253968],[0.34117647, 0.65882353],[1.? ? ? ? , 0.? ? ? ? ],[0.? ? ? ? , 1.? ? ? ? ],[0.? ? ? ? , 1.? ? ? ? ],[0.08379888, 0.91620112],[0.31693989, 0.68306011],[0.02923977, 0.97076023],[0.97687861, 0.02312139],[0.97765363, 0.02234637],
3 隨機貼片與隨機子空間
BaggingClassifier也支持采樣特征。它被兩個超參數max_features和bootstrap_features控制。他們的工作方式和max_samples和bootstrap一樣，但這是對于特征采樣而不是實例采樣。因此，每一個分類器都會被在隨機的輸入特征內進行訓練。
當你在處理高維度輸入下（例如圖片）此方法尤其有效。對訓練實例和特征的采樣被叫做隨機貼片。保留了所有的訓練實例（例如bootstrap=False和max_samples=1.0），但是對特征采樣（bootstrap_features=True并且/或者max_features小于 1.0）叫做隨機子空間。
采樣特征導致更多的預測多樣性，用高偏差換低方差。
4 隨機森林
正如我們所討論的，隨機森林是決策樹的一種集成，通常是通過bagging方法（有時是pasting方法）進行訓練，通常用max_samples設置為訓練集的大小。與建立一個BaggingClassifier然后把它放入DecisionTreeClassifier相反，你可以使用更方便的也是對決策樹優化夠的RandomForestClassifier（對于回歸是RandomForestRegressor）。接下來的代碼訓練了帶有500個樹（每個被限制為16葉子結點）的決策森林，使用所有空閑的 CPU 核：
fromsklearn.ensembleimportRandomForestClassifierrnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1, random_state=42)rnd_clf.fit(X_train, y_train)y_pred_rf = rnd_clf.predict(X_test)
除了一些例外，RandomForestClassifier使用DecisionTreeClassifier的所有超參數（決定數怎么生長），把BaggingClassifier的超參數加起來來控制集成本身。
隨機森林算法在樹生長時引入了額外的隨機；與在節點分裂時需要找到最好分裂特征相反（詳見第六章），它在一個隨機的特征集中找最好的特征。它導致了樹的差異性，并且再一次用高偏差換低方差，總的來說是一個更好的模型。以下是BaggingClassifier大致相當于之前的randomforestclassifier：
bag_clf = BaggingClassifier(? ? DecisionTreeClassifier(splitter="random", max_leaf_nodes=16, random_state=42),? ? n_estimators=500, max_samples=1.0, bootstrap=True, n_jobs=-1, random_state=42)bag_clf.fit(X_train, y_train)y_pred = bag_clf.predict(X_test)
np.sum(y_pred == y_pred_rf) / len(y_pred)# almost identical predictions0.976
4.1 極端隨機樹
當你在隨機森林上生長樹時，在每個結點分裂時只考慮隨機特征集上的特征（正如之前討論過的一樣）。相比于找到更好的特征我們可以通過使用對特征使用隨機閾值使樹更加隨機（像規則決策樹一樣）。
這種極端隨機的樹被簡稱為Extremely Randomized Trees（極端隨機樹），或者更簡單的稱為Extra-Tree。再一次用高偏差換低方差。它還使得Extra-Tree比規則的隨機森林更快地訓練，因為在每個節點上找到每個特征的最佳閾值是生長樹最耗時的任務之一。
你可以使用sklearn的ExtraTreesClassifier來創建一個Extra-Tree分類器。他的API跟RandomForestClassifier是相同的，相似的，ExtraTreesRegressor跟RandomForestRegressor也是相同的 API。
我們很難去分辨ExtraTreesClassifier和RandomForestClassifier到底哪個更好。通常情況下是通過交叉驗證來比較它們（使用網格搜索調整超參數）。
4.2 特征重要度
最后，如果你觀察一個單一決策樹，重要的特征會出現在更靠近根部的位置，而不重要的特征會經常出現在靠近葉子的位置。因此我們可以通過計算一個特征在森林的全部樹中出現的平均深度來預測特征的重要性。sklearn 在訓練后會自動計算每個特征的重要度。你可以通過feature_importances_變量來查看結果。例如如下代碼在 iris 數據集（第四章介紹）上訓練了一個RandomForestClassifier模型，然后輸出了每個特征的重要性?？磥恚钪匾奶卣魇腔ò觊L度（44%）和寬度（42%），而萼片長度和寬度相對比較是不重要的（分別為 11% 和 2%）：
fromsklearn.datasetsimportload_irisiris = load_iris()rnd_clf = RandomForestClassifier(n_estimators=500, n_jobs=-1, random_state=42)rnd_clf.fit(iris["data"], iris["target"])forname, scoreinzip(iris["feature_names"], rnd_clf.feature_importances_):? ? print(name, score)sepal length (cm)0.112492250999sepal width (cm)0.0231192882825petal length (cm)0.441030464364petal width (cm)0.423357996355
rnd_clf.feature_importances_array([0.11249225, 0.02311929, 0.44103046, 0.423358? ])
相似的，如果你在 MNIST 數據及上訓練隨機森林分類器（在第三章上介紹），然后畫出每個像素的重要性，你可以得到圖 7-6 的圖片。
from scipy.io import loadmatmnist = loadmat('./datasets/mnist-original.mat')mnist{'__globals__': [],'__header__':b'MATLAB 5.0 MAT-file Platform: posix, Created on: Sun Mar 30 03:19:02 2014','__version__':'1.0','data':array([[0,0,0, ...,0,0,0],? ? ? ? [0,0,0, ...,0,0,0],? ? ? ? [0,0,0, ...,0,0,0],? ? ? ? ...,? ? ? ? [0,0,0, ...,0,0,0],? ? ? ? [0,0,0, ...,0,0,0],? ? ? ? [0,0,0, ...,0,0,0]], dtype=uint8),'label':array([[0.,0.,0., ...,9.,9.,9.]]),'mldata_descr_ordering':array([[array(['label'],? ? ? ? dtype='<U5'),array(['data'],? ? ? ? dtype='<U4')]], dtype=object)}
X,y = mnist['data'].T,mnist['label'].TX.shape(70000, 784)y.shape(70000, 1)
rnd_clf = RandomForestClassifier(random_state=42)rnd_clf.fit(X, y)RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',? ? ? ? ? ? max_depth=None, max_features='auto', max_leaf_nodes=None,? ? ? ? ? ? min_impurity_decrease=0.0, min_impurity_split=None,? ? ? ? ? ? min_samples_leaf=1, min_samples_split=2,? ? ? ? ? ? min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,? ? ? ? ? ? oob_score=False, random_state=42, verbose=0, warm_start=False)
# mnist_feature_importance_plotdefplot_digit(data):image = data.reshape(28,28)? ? plt.imshow(image, cmap = matplotlib.cm.hot,? ? ? ? ? ? ? interpolation="nearest")? ? plt.axis("off")? ? plot_digit(rnd_clf.feature_importances_)cbar = plt.colorbar(ticks=[rnd_clf.feature_importances_.min(), rnd_clf.feature_importances_.max()])cbar.ax.set_yticklabels(['Not important','Very important'])plt.show()
隨機森林可以非常方便快速得了解哪些特征實際上是重要的，特別是你需要進行特征選擇的時候。
5 提升
提升（Boosting，最初稱為假設增強）指的是可以將幾個弱學習者組合成強學習者的集成方法。對于大多數的提升方法的思想就是按順序去訓練分類器，每一個都要嘗試修正前面的分類。現如今已經有很多的提升方法了，但最著名的就是Adaboost（適應性提升，是Adaptive Boosting的簡稱） 和Gradient Boosting（梯度提升）。讓我們先從Adaboost說起。
5.1 Adaboost
使一個新的分類器去修正之前分類結果的方法就是對之前分類結果不對的訓練實例多加關注。這導致新的預測因子越來越多地聚焦于這種情況。這是Adaboost使用的技術。
舉個例子，去構建一個Adaboost分類器，
第一個基分類器（例如一個決策樹）被訓練然后在訓練集上做預測，在誤分類訓練實例上的權重就增加了;
第二個分類機使用更新過的權重然后再一次訓練，權重更新，以此類推（詳見圖 7-7）
圖 7-8 顯示連續五次預測的moons數據集的決策邊界（在本例中，每一個分類器都是高度正則化帶有RBF核的SVM）。
第一個分類器誤分類了很多實例，所以它們的權重被提升了。
第二個分類器因此對這些誤分類的實例分類效果更好，以此類推。
右邊的圖代表了除了學習率減半外（誤分類實例權重每次迭代上升一半）相同的預測序列。
你可以看出，序列學習技術與梯度下降很相似，除了調整單個預測因子的參數以最小化代價函數之外，AdaBoost 增加了集合的預測器，逐漸使其更好。
一旦所有的分類器都被訓練后，除了分類器根據整個訓練集上的準確率被賦予的權重外，集成預測就非常像Bagging和Pasting了。
序列學習技術的一個重要的缺點就是：它不能被并行化（只能按步驟），因為每個分類器只能在之前的分類器已經被訓練和評價后再進行訓練。因此，它不像Bagging和Pasting一樣。
讓我們詳細看一下Adaboost算法。每一個實例的權重wi初始都被設為1/m第一個分類器被訓練，然后他的權重誤差率r1在訓練集上算出，詳見公式 7-1。
sklearn通常使用Adaboost的多分類版本SAMME（這就代表了分段加建模使用多類指數損失函數）。如果只有兩類別，那么SAMME是與Adaboost相同的。如果分類器可以預測類別概率（例如如果它們有predict_proba()），如果sklearn可以使用SAMME叫做SAMME.R的變量（R 代表“REAL”），這種依賴于類別概率的通常比依賴于分類器的更好。
接下來的代碼訓練了使用sklearn的AdaBoostClassifier基于200個決策樹樁Adaboost分類器（正如你說期待的，對于回歸也有AdaBoostRegressor）。一個決策樹樁是max_depth=1的決策樹-換句話說，是一個單一的決策節點加上兩個葉子結點。這就是AdaBoostClassifier的默認基分類器：
fromsklearn.ensembleimportAdaBoostClassifierada_clf = AdaBoostClassifier(? ? DecisionTreeClassifier(max_depth=1), n_estimators=200,? ? algorithm="SAMME.R", learning_rate=0.5, random_state=42)ada_clf.fit(X_train, y_train)
如果你的Adaboost集成過擬合了訓練集，你可以嘗試減少基分類器的數量或者對基分類器使用更強的正則化。
5.2 梯度提升
另一個非常著名的提升算法是梯度提升。與Adaboost一樣，梯度提升也是通過向集成中逐步增加分類器運行的，每一個分類器都修正之前的分類結果。然而，它并不像Adaboost那樣每一次迭代都更改實例的權重，這個方法是去使用新的分類器去擬合前面分類器預測的殘差。
讓我們通過一個使用決策樹當做基分類器的簡單的回歸例子（回歸當然也可以使用梯度提升）。這被叫做梯度提升回歸樹（GBRT，Gradient Tree Boosting或者Gradient Boosted Regression Trees）。
首先我們用DecisionTreeRegressor去擬合訓練集（例如一個有噪二次訓練集）：
fromsklearn.treeimportDecisionTreeRegressor tree_reg1 = DecisionTreeRegressor(max_depth=2) tree_reg1.fit(X, y)
現在在第一個分類器的殘差上訓練第二個分類器：
y2 = y - tree_reg1.predict(X)
tree_reg2 = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg2.fit(X, y2)
隨后在第二個分類器的殘差上訓練第三個分類器：
y3 = y2 - tree_reg2.predict(X)
tree_reg3 = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg3.fit(X, y3)
現在我們有了一個包含三個回歸器的集成。它可以通過集成所有樹的預測來在一個新的實例上進行預測。
X_new = np.array([[0.8]])y_pred = sum(tree.predict(X_new)fortreein(tree_reg1, tree_reg2, tree_reg3))y_pred
# gradient_boosting_plotdef plot_predictions(regressors, X, y, axes, label=None, style="r-", data_style="b.", data_label=None):? ? x1 = np.linspace(axes[0], axes[1], 500)? ? y_pred = sum(regressor.predict(x1.reshape(-1, 1))forregressorinregressors)? ? plt.plot(X[:, 0], y, data_style, label=data_label)? ? plt.plot(x1, y_pred, style, linewidth=2, label=label)iflabel or data_label:? ? ? ? plt.legend(loc="upper center", fontsize=16)? ? plt.axis(axes)plt.figure(figsize=(11,11))plt.subplot(321)plot_predictions([tree_reg1], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label="$h_1(x_1)$", style="g-", data_label="Training set")plt.ylabel("$y$", fontsize=16, rotation=0)plt.title("Residuals and tree predictions", fontsize=16)plt.subplot(322)plot_predictions([tree_reg1], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label="$h(x_1) = h_1(x_1)$", data_label="Training set")plt.ylabel("$y$", fontsize=16, rotation=0)plt.title("Ensemble predictions", fontsize=16)plt.subplot(323)plot_predictions([tree_reg2], X, y2, axes=[-0.5, 0.5, -0.5, 0.5], label="$h_2(x_1)$", style="g-", data_style="k+", data_label="Residuals")plt.ylabel("$y- h_1(x_1)$", fontsize=16)plt.subplot(324)plot_predictions([tree_reg1, tree_reg2], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label="$h(x_1) = h_1(x_1) + h_2(x_1)$")plt.ylabel("$y$", fontsize=16, rotation=0)plt.subplot(325)plot_predictions([tree_reg3], X, y3, axes=[-0.5, 0.5, -0.5, 0.5], label="$h_3(x_1)$", style="g-", data_style="k+")plt.ylabel("$y- h_1(x_1) - h_2(x_1)$", fontsize=16)plt.xlabel("$x_1$", fontsize=16)plt.subplot(326)plot_predictions([tree_reg1, tree_reg2, tree_reg3], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label="$h(x_1) = h_1(x_1) + h_2(x_1) + h_3(x_1)$")plt.xlabel("$x_1$", fontsize=16)plt.ylabel("$y$", fontsize=16, rotation=0)plt.show()
圖7-9在左欄展示了這三個樹的預測，在右欄展示了集成的預測。
在第一行，集成只有一個樹，所以它與第一個樹的預測相似。
在第二行，一個新的樹在第一個樹的殘差上進行訓練。在右邊欄可以看出集成的預測等于前兩個樹預測的和。
相同的，在第三行另一個樹在第二個數的殘差上訓練。你可以看到集成的預測會變的更好。
我們可以使用sklean中的GradientBoostingRegressor來訓練GBRT集成。與RandomForestClassifier相似，它也有超參數去控制決策樹的生長（例如max_depth，min_samples_leaf等等），也有超參數去控制集成訓練，例如基分類器的數量（n_estimators）。接下來的代碼創建了與之前相同的集成：
fromsklearn.ensembleimportGradientBoostingRegressorgbrt = GradientBoostingRegressor(max_depth=2, n_estimators=3, learning_rate=1.0, random_state=42)gbrt.fit(X, y)gbrt_slow = GradientBoostingRegressor(max_depth=2, n_estimators=200, learning_rate=0.1, random_state=42)gbrt_slow.fit(X, y)
# gbrt_learning_rate_plotplt.figure(figsize=(11,4))plt.subplot(121)plot_predictions([gbrt], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label="Ensemble predictions")plt.title("learning_rate={}, n_estimators={}".format(gbrt.learning_rate, gbrt.n_estimators), fontsize=14)plt.subplot(122)plot_predictions([gbrt_slow], X, y, axes=[-0.5, 0.5, -0.1, 0.8])plt.title("learning_rate={}, n_estimators={}".format(gbrt_slow.learning_rate, gbrt_slow.n_estimators), fontsize=14)plt.show()
超參數learning_rate確立了每個樹的貢獻。如果你把它設置為一個很小的樹，例如0.1，在集成中就需要更多的樹去擬合訓練集，但預測通常會更好。這個正則化技術叫做shrinkage。
圖 7-10 展示了兩個在低學習率上訓練的GBRT集成：其中左面是一個沒有足夠樹去擬合訓練集的樹，右面是有過多的樹過擬合訓練集的樹。
早停技術
為了找到樹的最優數量，你可以使用早停技術（第四章討論）。
最簡單使用這個技術的方法就是使用staged_predict()：
它在訓練的每個階段（用一棵樹，兩棵樹等）返回一個迭代器。加下來的代碼用120個樹訓練了一個GBRT集成，然后在訓練的每個階段驗證錯誤以找到樹的最佳數量，最后使用GBRT樹的最優數量訓練另一個集成：
importnumpyasnpfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportmean_squared_errorX_train, X_val, y_train, y_val = train_test_split(X, y, random_state=49)gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=120, random_state=42)gbrt.fit(X_train, y_train)errors = [mean_squared_error(y_val, y_pred)fory_predingbrt.staged_predict(X_val)]bst_n_estimators = np.argmin(errors)gbrt_best = GradientBoostingRegressor(max_depth=2,n_estimators=bst_n_estimators, random_state=42)gbrt_best.fit(X_train, y_train)min_error = np.min(errors)# early_stopping_gbrt_plotplt.figure(figsize=(11,4))plt.subplot(121)plt.plot(errors,"b.-")plt.plot([bst_n_estimators, bst_n_estimators], [0, min_error],"k--")plt.plot([0,120], [min_error, min_error],"k--")plt.plot(bst_n_estimators, min_error,"ko")plt.text(bst_n_estimators, min_error*1.2,"Minimum", ha="center", fontsize=14)plt.axis([0,120,0,0.01])plt.xlabel("Number of trees")plt.title("Validation error", fontsize=14)plt.subplot(122)plot_predictions([gbrt_best], X, y, axes=[-0.5,0.5,-0.1,0.8])plt.title("Best model (%d trees)"% bst_n_estimators, fontsize=14)plt.show()
驗證錯誤在圖 7-11 的左面展示，最優模型預測被展示在右面。
你也可以早早的停止訓練來實現早停（與先在一大堆樹中訓練，然后再回頭去找最優數目相反）。你可以通過設置warm_start=True來實現 ，這使得當fit()方法被調用時sklearn保留現有樹，并允許增量訓練。接下來的代碼在當一行中的五次迭代驗證錯誤沒有改善時會停止訓練：
gbrt = GradientBoostingRegressor(max_depth=2, warm_start=True, random_state=42)min_val_error =float("inf")error_going_up = 0forn_estimatorsinrange(1, 120):? ? gbrt.n_estimators = n_estimators? ? gbrt.fit(X_train, y_train)? ? y_pred = gbrt.predict(X_val)? ? val_error = mean_squared_error(y_val, y_pred)ifval_error < min_val_error:? ? ? ? min_val_error = val_error? ? ? ? error_going_up = 0else:? ? ? ? error_going_up += 1iferror_going_up == 5:break# early stoppingprint(gbrt.n_estimators)print("Minimum validation MSE:", min_val_error)61Minimum validation MSE: 0.00271285332524
GradientBoostingRegressor也支持指定用于訓練每棵樹的訓練實例比例的超參數subsample。例如如果subsample=0.25，那么每個樹都會在25%隨機選擇的訓練實例上訓練。你現在也能猜出來，這也是個高偏差換低方差的作用。它同樣也加速了訓練。這個技術叫做隨機梯度提升。
也可能對其他損失函數使用梯度提升。這是由損失超參數控制（見sklearn文檔）。
6 Stacking
本章討論的最后一個集成方法叫做Stacking（stacked generalization的縮寫）。這個算法基于一個簡單的想法：不使用瑣碎的函數（如硬投票）來聚合集合中所有分類器的預測，我們為什么不訓練一個模型來執行這個聚合？
圖 7-12 展示了這樣一個在新的回歸實例上預測的集成。底部三個分類器每一個都有不同的值（3.1，2.7 和 2.9），然后最后一個分類器（叫做blender或者meta learner）把這三個分類器的結果當做輸入然后做出最終決策（3.0）。
為了訓練這個blender，一個通用的方法是采用保持集。讓我們看看它怎么工作。
首先，訓練集被分為兩個子集，第一個子集被用作訓練第一層（詳見圖 7-13）.
接下來，第一層的分類器被用來預測第二個子集（保持集）（詳見 7-14）。這確保了預測結果很“干凈”，因為這些分類器在訓練的時候沒有使用過這些事例?，F在對在保持集中的每一個實例都有三個預測值。我們現在可以使用這些預測結果作為輸入特征來創建一個新的訓練集（這使得這個訓練集是三維的），并且保持目標數值不變。隨后blender在這個新的訓練集上訓練，因此，它學會了預測第一層預測的目標值。
顯然我們可以用這種方法訓練不同的blender（例如一個線性回歸，另一個是隨機森林等等）：我們得到了一層blender。訣竅是將訓練集分成三個子集：第一個子集用來訓練第一層，第二個子集用來創建訓練第二層的訓練集（使用第一層分類器的預測值），第三個子集被用來創建訓練第三層的訓練集（使用第二層分類器的預測值）。以上步驟做完了，我們可以通過逐個遍歷每個層來預測一個新的實例。詳見圖 7-15.
然而不幸的是，sklearn并不直接支持stacking，但是你自己組建是很容易的（看接下來的練習）?；蛘吣阋部梢允褂瞄_源的項目例如brew（網址為https://github.com/viisar/brew）
安裝brew
pip install git+https://github.com/viisar/brew.git
importnumpyasnpimportmatplotlib.pyplotaspltimportmatplotlib.gridspecasgridspecimportitertoolsimportsklearnfromsklearn.linear_modelimportLogisticRegressionfromsklearn.svmimportSVCfromsklearn.ensembleimportRandomForestClassifierfrombrew.baseimportEnsemble, EnsembleClassifierfrombrew.stacking.stackerimportEnsembleStack, EnsembleStackClassifierfrombrew.combination.combinerimportCombinerfrommlxtend.dataimportiris_datafrommlxtend.plottingimportplot_decision_regions# Initializing Classifiersclf1 = LogisticRegression(random_state=0)clf2 = RandomForestClassifier(random_state=0)clf3 = SVC(random_state=0, probability=True)# Creating Ensembleensemble = Ensemble([clf1, clf2, clf3])eclf = EnsembleClassifier(ensemble=ensemble, combiner=Combiner('mean'))# Creating Stackinglayer_1 = Ensemble([clf1, clf2, clf3])layer_2 = Ensemble([sklearn.clone(clf1)])stack = EnsembleStack(cv=3)stack.add_layer(layer_1)stack.add_layer(layer_2)sclf = EnsembleStackClassifier(stack)clf_list = [clf1, clf2, clf3, eclf, sclf]lbl_list = ['Logistic Regression','Random Forest','RBF kernel SVM','Ensemble','Stacking']# Loading some example dataX, y = iris_data()X = X[:,[0,2]]# WARNING, WARNING, WARNING# brew requires classes from 0 to N, no skipping allowedd = {yi : ifori, yiinenumerate(set(y))}y = np.array([d[yi]foryiiny])# Plotting Decision Regionsgs = gridspec.GridSpec(2,3)fig = plt.figure(figsize=(10,8))itt = itertools.product([0,1,2], repeat=2)forclf, lab, grdinzip(clf_list, lbl_list, itt):? ? clf.fit(X, y)? ? ax = plt.subplot(gs[grd[0], grd[1]])? ? fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)? ? plt.title(lab)plt.show()
7 思考題
如果你在相同訓練集上訓練 5 個不同的模型，它們都有 95% 的準確率，那么你是否可以通過組合這個模型來得到更好的結果？如果可以那怎么做呢？如果不可以請給出理由。
軟投票和硬投票分類器之間有什么區別？
是否有可能通過分配多個服務器來加速 bagging 集成系統的訓練？pasting 集成，boosting 集成，隨機森林，或 stacking 集成怎么樣？
out-of-bag 評價的好處是什么？
是什么使 Extra-Tree 比規則隨機森林更隨機呢？這個額外的隨機有什么幫助呢？那這個 Extra-Tree 比規則隨機森林誰更快呢？
如果你的 Adaboost 模型欠擬合，那么你需要怎么調整超參數？
如果你的梯度提升過擬合，那么你應該調高還是調低學習率呢？
導入 MNIST 數據（第三章中介紹），把它切分進一個訓練集，一個驗證集，和一個測試集（例如 40000 個實例進行訓練，10000 個進行驗證，10000 個進行測試）。然后訓練多個分類器，例如一個隨機森林分類器，一個 Extra-Tree 分類器和一個 SVM。接下來，嘗試將它們組合成集成，使用軟或硬投票分類器來勝過驗證集上的所有集合。一旦找到了，就在測試集上實驗。與單個分類器相比，它的性能有多好？
從練習 8 中運行個體分類器來對驗證集進行預測，并創建一個新的訓練集并生成預測：每個訓練實例是一個向量，包含來自所有分類器的圖像的預測集，目標是圖像類別。祝賀你，你剛剛訓練了一個blender，和分類器一起組成了一個疊加組合！現在讓我們來評估測試集上的集合。對于測試集中的每個圖像，用所有分類器進行預測，然后將預測饋送到blender以獲得集合的預測。它與你早期訓練過的投票分類器相比如何？
作者：7125messi
鏈接：http://www.lxweimin.com/p/7ea1b77ecb51
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯系作者獲得授權并注明出處。
