集成學習值Adaboost算法原理和代碼小結(轉載)

時間 2019-11-24

原文原文鏈接

在集成學習原理小結中，咱們講到了集成學習按照個體學習器之間是否存在依賴關係能夠分爲兩類：html

第一個是個體學習器之間存在強依賴關係；
另外一類是個體學習器之間不存在強依賴關係。

前者的表明算法就是提高(boosting)系列算法。在boosting系列算法中， Adaboost是最著名的算法之一。Adaboost既能夠用做分類，也能夠用做迴歸。本文就對Adaboost算法作一個總結。node

一回顧boosting算法的基本原理

AdaBoost是典型的Boosting算法，屬於Boosting家族的一員。在說AdaBoost以前，先說說Boosting提高算法。Boosting算法是將「弱學習算法「提高爲「強學習算法」的過程，主要思想是「三個臭皮匠頂個諸葛亮」。通常來講，找到弱學習算法要相對容易一些，而後經過反覆學習獲得一系列弱分類器，組合這些弱分類器獲得一個強分類器。Boosting算法要涉及到兩個部分，加法模型和前向分步算法。加法模型就是說強分類器由一系列弱分類器線性相加而成。通常組合形式以下：$$f(x;P)=\sum_{k=1}^Kβ_kh(x;\gamma_k)$$python

其中，$h(x;\gamma_k)$ 就是一個個的弱分類器，$\gamma_k$是弱分類器學習到的最優參數，$β_k$ 就是弱學習在強分類器中所佔比重，$P$ 是全部$\gamma_k$和$\beta_k$ 的組合。這些弱分類器線性相加組成強分類器。算法

前向分步就是說在訓練過程當中，下一輪迭代產生的分類器是在上一輪的基礎上訓練得來的。也就是能夠寫成這樣的形式：網絡

$$f _k(x)=f_{k-1}(x)+ β_kh_k(x;\gamma_k)$$框架

因爲採用的損失函數不一樣，Boosting算法也所以有了不一樣的類型，AdaBoost就是損失函數爲指數損失的Boosting算法。dom

在前面一節，咱們已經講到了boosting算法系列的基本思想，以下圖：機器學習

從圖中能夠看出，Boosting算法的工做機制是首先從訓練集用初始權重D(1)訓練出一個弱學習器1，根據弱學習的學習偏差率表現來更新訓練樣本的權重，使得以前弱學習器1學習偏差率高的訓練樣本點的權重變高，使得這些偏差率高的點在後面的弱學習器2中獲得更多的重視。而後基於調整權重後的訓練集來訓練弱學習器2.，如此重複進行，直到弱學習器數達到事先指定的數目T，最終將這T個弱學習器經過集合策略進行整合，獲得最終的強學習器。函數

在上圖中有幾個具體的問題咱們沒有詳細說明。post

如何計算分類偏差率e?
如何獲得弱學習器權重係數$\alpha$(即上式中的$β_k$)？
如何更新訓練數據的樣本權重D?
使用何種結合策略？

只要是boosting你們族的算法，都要解決這4個問題。那麼Adaboost是怎麼解決的呢？

二 Adaboost算法的基本思想

咱們這裏講解Adaboost是如何解決上面4個問題的。

假設咱們的訓練集樣本是：$$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$$

訓練集的在第k個弱學習器的樣本權重係數爲：$$D(k) = (w_{k1}, w_{k2}, ...w_{km}) ;\;\;\sum\limits_{i=1}^{m}w_{ki}=1;\;\;w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

注意：在初始化第一個弱分類器輸出權重時，咱們假設訓練集樣本具備均勻的權值分佈，即每一個訓練樣本在第一個弱分類器的學習中做用相同，這一假設保證能夠在訓練集樣本上學習第一個弱分類器$G_1(x)$。

首先咱們看看Adaboost的分類問題。

分類問題的偏差率很好理解和計算。因爲多元分類是二元分類的推廣，這裏假設咱們是二元分類問題，輸出爲{-1，1}，則第k個弱分類器$G_k(x)$在訓練集上的分類偏差率爲：$$e_k = P(G_k(x_i) \neq y_i) = \sum\limits_{i=1}^{m}w_{ki}I(G_k(x_i) \neq y_i)$$

接着咱們看弱學習器權重係數,對於二元分類問題，第k個弱分類器$G_k(x)$的權重係數爲：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

爲何這樣計算弱學習器權重係數？從上式能夠看出，若是分類偏差率$e_k$越大，則對應的弱分類器權重係數$\alpha_k$越小。也就是說，偏差率小的弱分類器權重係數越大。具體爲何採用這個權重係數公式，咱們在講Adaboost的損失函數優化時再講。

第三個問題，如何更新樣本權重D。假設第k個弱分類器的樣本集權重係數爲$D(k) = (w_{k1}, w_{k2}, ...w_{km})$，則對應的第k+1個弱分類器的樣本權重係數爲：$$w_{k+1,i} = \frac{w_{ki}}{Z_K}exp(-\alpha_ky_iG_k(x_i))$$

這裏$Z_k$是規範化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}exp(-\alpha_ky_iG_k(x_i))$$

從$w_{k+1,i}$計算公式能夠看出，若是第i個樣本分類錯誤，則$y_iG_k(x_i) < 0$，致使樣本的權重在第k+1個弱分類器中增大，若是分類正確，則權重在第k+1個弱分類器中減小.不改變所給的訓練集數據，經過不斷的改變訓練樣本的權重，使得訓練集數據在弱分類器的學習中起不一樣的做用。具體爲何採用這個樣本權重更新公式，咱們在講Adaboost的損失函數優化時再講。

最後一個問題是集合策略。Adaboost分類採用的是加權平均法，最終的強分類器爲：$$f(x) = sign(\sum\limits_{k=1}^{K}\alpha_kG_k(x))$$

係數$\alpha_k$表示了弱分類器$G_k(x)$的重要性，這裏全部$\alpha$之和並不爲1，$f(x)$的符號決定實例$x$的類，$f(x)$的絕對值表示分類的置信度。

接着咱們看看Adaboost的迴歸問題。因爲Adaboost的迴歸問題有不少變種，這裏咱們以Adaboost R2算法爲準。

咱們先看看回歸問題的偏差率的問題，對於第k個弱學習器，計算他在訓練集上的最大偏差：$$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$$

而後計算每一個樣本的相對偏差$$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$$

這裏是偏差損失爲線性時的狀況，若是咱們用平方偏差，則$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$,若是咱們用的是指數偏差，則$e_{ki}= 1 - exp（\frac{-y_i + G_k(x_i))}{E_k}）$

最終獲得第k個弱學習器的偏差率：$$e_k = \sum\limits_{i=1}^{m}w_{ki}e_{ki}$$

咱們再來看看如何獲得弱學習器權重係數$\alpha$。這裏有：$$\alpha_k =\frac{e_k}{1-e_k}$$

對於更新更新樣本權重D，第k+1個弱學習器的樣本集權重係數爲：$$w_{k+1,i} = \frac{w_{ki}}{Z_k}\alpha_k^{1-e_{ki}}$$

這裏$Z_k$是規範化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}\alpha_k^{1-e_{ki}}$$

最後是結合策略，和分類問題稍有不一樣，採用的是對加權的弱學習器取中位數的方法，最終的強迴歸器爲：$$f(x) = \sum\limits_{k=1}^{K}(ln\frac{1}{\alpha_k})g(x)$$

其中，$g(x)$是全部$\alpha_kG_k(x), k=1,2,....K$的中位數。　

三 AdaBoost分類問題的損失函數優化

上面咱們講到了分類Adaboost的弱學習器權重係數公式和樣本權重更新公式。可是沒有解釋選擇這個公式的緣由，讓人以爲是魔法公式同樣。其實它能夠從Adaboost的損失函數推導出來。

從另外一個角度講，Adaboost是模型爲加法模型，學習算法爲前向分步學習算法，損失函數爲指數函數的分類問題。

模型爲加法模型好理解，咱們的最終的強分類器是若干個弱分類器加權平均而獲得的。

前向分步學習算法也好理解，咱們的算法是經過一輪輪的弱學習器學習，利用前一個弱學習器的結果來更新後一個弱學習器的訓練集權重。也就是說，第k-1輪的強學習器爲：$$f_{k-1}(x) = \sum\limits_{i=1}^{k-1}\alpha_iG_{i}(x)$$

而第k輪的強學習器爲：$$f_{k}(x) = \sum\limits_{i=1}^{k}\alpha_iG_{i}(x)$$

上兩式一比較能夠獲得：$$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $$

可見強學習器的確是經過前向分步學習算法一步步而獲得的。

Adaboost損失函數爲指數函數，即定義損失函數爲：$$loss=\sum\limits_{i=1}^{m}exp(-y_if_{k}(x_i))$$

利用前向分步學習算法的關係能夠獲得損失函數爲：$$loss=\sum\limits_{i=1}^{m}exp[-y_i(f_{k-1}(x_i) + \alpha_kG_k(x_i))]$$

假設已經通過了$k-1$次迭代，$f_{k-1}(x)$已知，令$w_{ki}^{’} = exp(-y_if_{k-1}(x_i))$, $w_{ki}^{’}$依賴於$f_{k-1}(x_i)$。

將$w_{ki}^{’}$帶入損失函數,損失函數轉化爲：$$loss=\sum\limits_{i=1}^{m}w_{ki}^{’}exp[-y_i\alpha_k G_k(x_i)]$$咱們繼續化簡$loss$:$$loss=\sum\limits_{y_i=G_k(x_i)}w_{ki}^{'}exp(-\alpha_k)+\sum\limits_{y_i \neq G_k(x_i)}w_{ki}^{'}exp(\alpha_k)$$

$$=(exp(\alpha_k)-exp(-\alpha_k))\sum\limits_{i=1}^{m}w_{ki}^{'}I(y_i \neq G_k(x_i))+exp(-\alpha_k)\sum\limits_{i=1}^{m}w_{ki}^{'}$$

並對$\alpha$求導，使其等於0，則就獲得了：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

其中，$e_k$即爲咱們前面的分類偏差率。$$e_k = \frac{\sum\limits_{i=1}^{m}w_{ki}^{’}I(y_i \neq G(x_i))}{\sum\limits_{i=1}^{m}w_{ki}^{’}} = \sum\limits_{i=1}^{m}w_{ki}I(y_i \neq G(x_i))$$

最後看樣本權重的更新。利用$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $和$w_{ki}^{’} = exp(-y_if_{k-1}(x))$，便可得：$$w_{k+1,i}^{’} = w_{ki}^{’}exp[-y_i\alpha_kG_k(x)]$$

這與咱們上面說到的樣本權重的更新只差一個規範化因子$Z_k$，二者是等價的。

四 AdaBoost二元分類問題算法流程

這裏咱們對AdaBoost二元分類問題算法流程作一個總結。

輸入爲樣本集$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$，輸出爲{-1, +1}，弱分類器算法, 弱分類器迭代次數K。

輸出爲最終的強分類器$f(x)$

1) 初始化樣本集權重爲：$$D(1) = (w_{11}, w_{12}, ...w_{1m}) ;\;\; w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

2) 對於k=1,2，...K:

a) 使用具備權重$D_k$的樣本集來訓練數據，獲得弱分類器$G_k(x)$

b)計算$G_k(x)$的分類偏差率：$$e_k = P(G_k(x_i) \neq y_i) = \sum\limits_{i=1}^{m}w_{ki}I(G_k(x_i) \neq y_i)$$

c) 計算弱分類器的係數：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

d) 更新樣本集的權重分佈：$$w_{k+1,i} = \frac{w_{ki}}{Z_K}exp(-\alpha_ky_iG_k(x_i)) \;\; i =1,2,...m$$

這裏$Z_k$是規範化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}exp(-\alpha_ky_iG_k(x_i))$$

3) 構建最終分類器爲：$$f(x) = sign(\sum\limits_{k=1}^{K}\alpha_kG_k(x))$$　　　　

對於Adaboost多元分類算法，其實原理和二元分類相似，最主要區別在弱分類器的係數上。好比Adaboost SAMME算法，它的弱分類器的係數：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k} + log(R-1)$$

其中R爲類別數。從上式能夠看出，若是是二元分類，R=2，則上式和咱們的二元分類算法中的弱分類器的係數一致。

五 Adaboost迴歸問題的算法流程

這裏咱們對AdaBoost迴歸問題算法流程作一個總結。AdaBoost迴歸算法變種不少，下面的算法爲Adaboost R2迴歸算法過程。

輸入爲樣本集$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$，，弱學習器算法, 弱學習器迭代次數K。

輸出爲最終的強學習器$f(x)$

1) 初始化樣本集權重爲：$$D(1) = (w_{11}, w_{12}, ...w_{1m}) ;\;\; w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

2) 對於k=1,2，...K:

a) 使用具備權重$D_k$的樣本集來訓練數據，獲得弱學習器$G_k(x)$

b) 計算訓練集上的最大偏差：$$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$$

c) 計算每一個樣本的相對偏差:

若是是線性偏差，則$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$；

若是是平方偏差，則$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$

若是是指數偏差，則$e_{ki}= 1 - exp（\frac{-|y_i -G_k(x_i)|}{E_k}）$　　　　　　　　

d) 計算迴歸偏差率：$$e_k = \sum\limits_{i=1}^{m}w_{ki}e_{ki}$$

c) 計算弱學習器的係數：$$\alpha_k =\frac{e_k}{1-e_k}$$

d) 更新樣本集的權重分佈爲：$$w_{k+1,i} = \frac{w_{ki}}{Z_k}\alpha_k^{1-e_{ki}}$$

這裏$Z_k$是規範化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}\alpha_k^{1-e_{ki}}$$

3) 構建最終強學習器爲：$$f(x) = \sum\limits_{k=1}^{K}(ln\frac{1}{\alpha_k})g(x)$$

其中，$g(x)$是全部$\alpha_kG_k(x), k=1,2,....K$的中位數。　

六 Adaboost算法的正則化

爲了防止Adaboost過擬合，咱們一般也會加入正則化項，這個正則化項咱們一般稱爲步長(learning rate)。定義爲$\nu$,對於前面的弱學習器的迭代：$$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $$

若是咱們加上了正則化項，則有：$$f_{k}(x) = f_{k-1}(x) + \nu\alpha_kG_k(x) $$

$\nu$的取值範圍爲$0 < \nu \leq 1 $。對於一樣的訓練集學習效果，較小的$\nu$意味着咱們須要更多的弱學習器的迭代次數。一般咱們用步長和迭代最大次數一塊兒來決定算法的擬合效果。

七 Adaboost的例子

給定以下表所示訓練數據，假設弱分類器由$x<v$或$x>v$產生，能夠看作由一個根節點直接鏈接兩個葉節點的簡單決策樹，其閾值$v$使該分類器在訓練數據集上的分類偏差率最低，試用Adaboost算法學習一個強分類器。

序號	1	2	3	4	5	6	7	8	9	10
$x$	0	1	2	3	4	5	6	7	8	9
$y$	1	1	1	-1	-1	-1	1	1	1	-1

解：初始化樣本權重係數：$$D_1={w_{11},w_{12},...,w_{110}};\;\;w_{1i}=0.1,i=1,2,...,10$$

對於$k$=1：

a、在權重爲$D_1$的訓練數據上、閾值$v$取2.5時分類偏差率最低，故弱分類器爲：$$G_1(x)=\begin{cases}1, { x<2.5}\\ - 1, {x>2.5 }\end{cases}$$

b、$G_1(x)$在訓練數據集上的分類偏差率$e_1=P(G_1(x_i) \neq y_i) = 0.3$

c、計算$G_1(x)$的係數:$\alpha_1=\frac{1}{2}log\frac{1-e_1}{e_1}=0.4236$

d、更新樣本的權重分佈:$$D_2={w_{21},...,w_{2i},...,w_{210}};\;\;w_{2i}=\frac{w_{1i}}{Z_1}exp(-\alpha_1 y_i G_1(x_i)), i=1,2,...,10$$ $$D_2=(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,0.16667,0.16667,0.16667,0.07143)$$ $$f_1(x)=0.4236G_1(x)$$

分類器$sign[f_1(x)]$在訓練數據集上有3個誤分類點。

對於$k$=2：

a、在權重爲$D_2$的訓練數據上、閾值$v$取8.5時分類偏差率最低，故弱分類器爲：$$G_2(x)=\begin{cases}1, { x<8.5}\\ - 1, {x>8.5 }\end{cases}$$

b、$G_2(x)$在訓練數據集上的分類偏差率$e_2=P(G_2(x_i) \neq y_i) = 0.2143$

c、計算$G_2(x)$的係數:$\alpha_2=\frac{1}{2}log\frac{1-e_2}{e_2}=0.6496$

d、更新樣本的權重分佈:$$D_3={w_{31},...,w_{3i},...,w_{310}};\;\;w_{3i}=\frac{w_{2i}}{Z_2}exp(-\alpha_2 y_i G_2(x_i)), i=1,2,...,10$$ $$D_3=(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667,0.1060,0.1060,0.1060,0.0455)$$ $$f_2(x)=0.4236G_1(x)+0.6496G_2(x)$$

分類器$sign[f_2(x)]$在訓練數據集上有3個誤分類點。

對於$k$=3：

a、在權重爲$D_3$的訓練數據上、閾值$v$取5.5時分類偏差率最低，故弱分類器爲：$$G_3(x)=\begin{cases}1, { x>5.5}\\ - 1, {x<5.5 }\end{cases}$$

b、$G_3(x)$在訓練數據集上的分類偏差率$e_3=P(G_3(x_i) \neq y_i) = 0.1820$

c、計算$G_3(x)$的係數:$\alpha_3=\frac{1}{2}log\frac{1-e_3}{e_3}=0.7514$

d、更新樣本的權重分佈:$$D_4={w_{41},...,w_{4i},...,w_{410}};\;\;w_{4i}=\frac{w_{3i}}{Z_3}exp(-\alpha_3 y_i G_3(x_i)), i=1,2,...,10$$ $$D_4=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125)$$ $$f_3(x)=0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)$$

分類器$sign[f_3(x)]$在訓練數據集上有0個誤分類點。

因而最終分類器爲：$$G(x)=sign[f_3(x)]=sign[0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)]$$

八 scikit-learn Adaboost類庫使用小結

1. Adaboost類庫概述

scikit-learn中Adaboost類庫比較直接，就是AdaBoostClassifier和AdaBoostRegressor兩個，從名字就能夠看出AdaBoostClassifier用於分類，AdaBoostRegressor用於迴歸。

AdaBoostClassifier使用了兩種Adaboost分類算法的實現，SAMME和SAMME.R。而AdaBoostRegressor則使用了講到的Adaboost迴歸算法的實現，即Adaboost.R2。

當咱們對Adaboost調參時，主要要對兩部份內容進行調參，第一部分是對咱們的Adaboost的框架進行調參，第二部分是對咱們選擇的弱分類器進行調參。二者相輔相成。下面就對Adaboost的兩個類：AdaBoostClassifier和AdaBoostRegressor從這兩部分作一個介紹。

2. AdaBoostClassifier和AdaBoostRegressor框架參數

咱們首先來看看AdaBoostClassifier和AdaBoostRegressor框架參數。二者大部分框架參數相同，下面咱們一塊兒討論這些參數，兩個類若是有不一樣點咱們會指出。

1）base_estimator：AdaBoostClassifier和AdaBoostRegressor都有，即咱們的弱分類學習器或者弱迴歸學習器。理論上能夠選擇任何一個分類或者回歸學習器，不過須要支持樣本權重。咱們經常使用的通常是CART決策樹或者神經網絡MLP。默認是決策樹，即AdaBoostClassifier默認使用CART分類樹DecisionTreeClassifier，而AdaBoostRegressor默認使用CART迴歸樹DecisionTreeRegressor。另外有一個要注意的點是，若是咱們選擇的AdaBoostClassifier算法是SAMME.R，則咱們的弱分類學習器還須要支持機率預測，也就是在scikit-learn中弱分類學習器對應的預測方法除了predict還須要有predict_proba。

2）algorithm：這個參數只有AdaBoostClassifier有。主要緣由是scikit-learn實現了兩種Adaboost分類算法，SAMME和SAMME.R。二者的主要區別是弱學習器權重的度量，SAMME使用了和咱們的原理篇裏二元分類Adaboost算法的擴展，即用對樣本集分類效果做爲弱學習器權重，而SAMME.R使用了對樣本集分類的預測機率大小來做爲弱學習器權重。因爲SAMME.R使用了機率度量的連續值，迭代通常比SAMME快，所以AdaBoostClassifier的默認算法algorithm的值也是SAMME.R。咱們通常使用默認的SAMME.R就夠了，可是要注意的是使用了SAMME.R，則弱分類學習器參數base_estimator必須限制使用支持機率預測的分類器。SAMME算法則沒有這個限制。

3）loss：這個參數只有AdaBoostRegressor有，Adaboost.R2算法須要用到。有線性‘linear’, 平方‘square’和指數 ‘exponential’三種選擇, 默認是線性，通常使用線性就足夠了，除非你懷疑這個參數致使擬合程度很差。這個值的意義在原理中咱們也講到了，它對應了咱們對第k個弱分類器的中第i個樣本的偏差的處理，即：若是是線性偏差，則$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$；若是是平方偏差，則$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$，若是是指數偏差，則$e_{ki}= 1 - exp（\frac{-y_i + G_k(x_i))}{E_k}）$，$E_k$爲訓練集上的最大偏差$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$

4) n_estimators： AdaBoostClassifier和AdaBoostRegressor都有，就是咱們的弱學習器的最大迭代次數，或者說最大的弱學習器的個數。通常來講n_estimators過小，容易欠擬合，n_estimators太大，又容易過擬合，通常選擇一個適中的數值。默認是50。在實際調參的過程當中，咱們經常將n_estimators和下面介紹的參數learning_rate一塊兒考慮。

5) learning_rate: AdaBoostClassifier和AdaBoostRegressor都有，即每一個弱學習器的權重縮減係數$\nu$，在原理中的正則化小節咱們也講到了，加上了正則化項，咱們的強學習器的迭代公式爲$f_{k}(x) = f_{k-1}(x) + \nu\alpha_kG_k(x) $。$\nu$的取值範圍爲$0 < \nu \leq 1 $。對於一樣的訓練集擬合效果，較小的$\nu$意味着咱們須要更多的弱學習器的迭代次數。一般咱們用步長和迭代最大次數一塊兒來決定算法的擬合效果。因此這兩個參數n_estimators和learning_rate要一塊兒調參。通常來講，能夠從一個小一點的$\nu$開始調參，默認是1。

3. AdaBoostClassifier和AdaBoostRegressor弱學習器參數

這裏咱們再討論下AdaBoostClassifier和AdaBoostRegressor弱學習器參數，因爲使用不一樣的弱學習器，則對應的弱學習器參數各不相同。這裏咱們僅僅討論默認的決策樹弱學習器的參數。即CART分類樹DecisionTreeClassifier和CART迴歸樹DecisionTreeRegressor。

DecisionTreeClassifier和DecisionTreeRegressor的參數基本相似，在scikit-learn決策樹算法類庫使用小結這篇文章中咱們對這兩個類的參數作了詳細的解釋。這裏咱們只拿出調參數時須要尤爲注意的最重要幾個的參數再拿出來講一遍：

1) 劃分時考慮的最大特徵數max_features: 可使用不少種類型的值，默認是"None",意味着劃分時考慮全部的特徵數；若是是"log2"意味着劃分時最多考慮 $l o g_{2} N$

個特徵；若是是"sqrt"或者"auto"意味着劃分時最多考慮$log_2N$個特徵。若是是整數，表明考慮的特徵絕對數。若是是浮點數，表明考慮特徵百分比，即考慮（百分比xN）取整後的特徵數。其中N爲樣本總特徵數。通常來講，若是樣本特徵數很少，好比小於50，咱們用默認的"None"就能夠了，若是特徵數很是多，咱們能夠靈活使用剛纔描述的其餘取值來控制劃分時考慮的最大特徵數，以控制決策樹的生成時間。

2) 決策樹最大深max_depth: 默承認以不輸入，若是不輸入的話，決策樹在創建子樹的時候不會限制子樹的深度。通常來講，數據少或者特徵少的時候能夠無論這個值。若是模型樣本量多，特徵也多的狀況下，推薦限制這個最大深度，具體的取值取決於數據的分佈。經常使用的能夠取值10-100之間。

3) 內部節點再劃分所需最小樣本數min_samples_split: 這個值限制了子樹繼續劃分的條件，若是某節點的樣本數少於min_samples_split，則不會繼續再嘗試選擇最優特徵來進行劃分。默認是2.若是樣本量不大，不須要管這個值。若是樣本量數量級很是大，則推薦增大這個值。

4) 葉子節點最少樣本數min_samples_leaf: 這個值限制了葉子節點最少的樣本數，若是某葉子節點數目小於樣本數，則會和兄弟節點一塊兒被剪枝。默認是1,能夠輸入最少的樣本數的整數，或者最少樣本數佔樣本總數的百分比。若是樣本量不大，不須要管這個值。若是樣本量數量級很是大，則推薦增大這個值。

5）葉子節點最小的樣本權重和min_weight_fraction_leaf：這個值限制了葉子節點全部樣本權重和的最小值，若是小於這個值，則會和兄弟節點一塊兒被剪枝。默認是0，就是不考慮權重問題。通常來講，若是咱們有較多樣本有缺失值，或者分類樹樣本的分佈類別誤差很大，就會引入樣本權重，這時咱們就要注意這個值了。

6) 最大葉子節點數max_leaf_nodes: 經過限制最大葉子節點數，能夠防止過擬合，默認是"None」，即不限制最大的葉子節點數。若是加了限制，算法會創建在最大葉子節點數內最優的決策樹。若是特徵很少，能夠不考慮這個值，可是若是特徵分紅多的話，能夠加以限制，具體的值能夠經過交叉驗證獲得。

4. AdaBoostClassifier實戰

這裏咱們用一個具體的例子來說解AdaBoostClassifier的使用。

首先咱們載入須要的類庫：

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_gaussian_quantiles

接着咱們生成一些隨機數據來作二元分類，若是對如何產生隨機數據不熟悉，在另外一篇文章機器學習算法的隨機數據生成中有比較詳細的介紹。

# 生成2維正態分佈，生成的數據按分位數分爲兩類，500個樣本,2個樣本特徵，協方差係數爲2
X1, y1 = make_gaussian_quantiles(cov=2.0,n_samples=500, n_features=2,n_classes=2, random_state=1)
# 生成2維正態分佈，生成的數據按分位數分爲兩類，400個樣本,2個樣本特徵均值都爲3，協方差係數爲2
X2, y2 = make_gaussian_quantiles(mean=(3, 3), cov=1.5,n_samples=400, n_features=2, n_classes=2, random_state=1)
#講兩組數據合成一組數據
X = np.concatenate((X1, X2))
y = np.concatenate((y1, - y2 + 1))

咱們經過可視化看看咱們的分類數據，它有兩個特徵，兩個輸出類別，用顏色區別。

plt.scatter(X[:, 0], X[:, 1], marker='o', c=y,s=10)

能夠看到數據有些混雜，咱們如今用基於決策樹的Adaboost來作分類擬合。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=200, learning_rate=0.8)
bdt.fit(X, y)

這裏咱們選擇了SAMME算法，最多200個弱分類器，步長0.8，在實際運用中你可能須要經過交叉驗證調參而選擇最好的參數。擬合完了後，咱們用網格圖來看看它擬合的區域。並把擬合的區域用輪廓繪製出來。

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))

Z = bdt.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
plt.scatter(X[:, 0], X[:, 1], marker='o', c=y)
plt.show()

從圖中能夠看出，咱們的樣本數據集基本上被輪廓分割開來，Adaboost的擬合效果仍是不錯的，如今咱們看看擬合分數：

print('Score:',bdt.score(X,y))

也就是說擬合訓練集數據的分數還不錯。固然分數高並不必定好，由於可能過擬合。

如今咱們將最大弱分離器個數從200增長到300。再來看看擬合分數。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=300, learning_rate=0.8)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此時的輸出爲：Score: 0.962222222222

這印證了咱們前面講的，弱分離器個數越多，則擬合程度越好，固然也越容易過擬合。

如今咱們下降步長，將步長從上面的0.8減小到0.5，再來看看擬合分數。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=300, learning_rate=0.5)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此時的輸出爲：Score: 0.894444444444

可見在一樣的弱分類器的個數狀況下，若是減小步長，擬合效果會降低。

最後咱們看看當弱分類器個數爲700，步長爲0.7時候的狀況：

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=600, learning_rate=0.7)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此時的輸出爲：Score: 0.961111111111

此時的擬合分數和咱們最初的300弱分類器，0.8步長的擬合程度至關。也就是說，在咱們這個例子中，若是步長從0.8降到0.7，則弱分類器個數要從300增長到700才能達到相似的擬合效果。