前言

前面的文章中介紹了決策樹以及其它一些演算法，但是，會發現，有時候使用使用這些演算法並不能達到特別好的效果。於是乎就有了整合學習（Ensemble Learning），通過構建多個學習器一起結合來完成具體的學習任務。這篇文章將介紹整合學習，以及其中的一種演算法 AdaBoost。

整合學習

首先先來介紹下什麼是整合學習：

• 構建多個學習器一起結合來完成具體的學習任務，常可獲得比單一學習器顯著優越的泛化效能，對“弱學習器” 尤為明顯（三個臭皮匠，頂個諸葛亮）
• 也稱為Multi-Classifier System, Committee-Based Learning
• 學習器可以是同類型的，也可以是不同型別

這麼一看，就感覺整合學習與常說的模型融合很像，甚至可以理解為就是模型融合。

那麼，常用的整合學習方法有哪些呢？

1. Boosting，將各種弱分類器串聯起來的整合學習方式，每一個分類器的訓練都依賴於前一個分類器的結果，代表：AdaBoost，Gradient Boosting Machine
2. Bagging，Bootstrap Aggregating 的縮寫。這種方法採用的是隨機有放回的選擇訓練資料然後構造分類器，最後進行組合，代表：Random Forest
3. Voting/Averaging，在不改變模型的情況下，直接對各個不同的模型預測的結果進行投票或者平均
4. Binning，最近看到的一種方法，還沒細看，參考論文
5. Stacking
6. Blending

後面幾種方法這裡暫時不做介紹，後面會單獨寫部落格來介紹這些方法

AdaBoost

演算法思想

這裡將介紹一個基於 Boosting 方法的一個學習演算法 AdaBoost，於1995年由 Freund 和 Schapire 提出。其主要思想為：

1. 先訓練出一個基學習器
2. 根據該學習器的表現對訓練樣本權重進行調整，使得現有基學習器做錯的樣本在後續學習器的訓練中受到更多的關注
3. 基於調整後的權重來訓練下一個基學習器
4. 重複 2、3 直至學習器數目達到事先指定的值 T
5. 最終將這 T 個學習器進行加權結合

\[ H(x)=\operatorname{sign}\left(\sum_{t=1}^{T} \alpha_{t} h_{t}(x)\right) \]

具體演算法

設訓練資料集
\[ \{x^{(i)}, y^{(i)}\}_{i=1}^{m},x^{(i)} \in \mathbb{R}^n, y \in \{-1, +1\} \]
初始化訓練資料的權值分佈
\[ \mathcal{D}_{1}\left(x^{(i)}\right)=\frac{1}{m} \]
for t in range(T):

​ 假設訓練得到分類器 \(h_t(x)\) ，則可計算 \(h_t(x)\) 在當前訓練集上的分類誤差：
\[ \epsilon_{t}=P_{x \sim \mathcal{D}_{t}}\left[h_{t}(x) \neq y\right]=\sum_{y^{(i)} \neq h_{t}\left(x^{(i)}\right)} \mathcal{D}_{t}\left(x^{(i)}\right) \]
​ 若 \(\epsilon_{t} > 0.5\), break; 否則計算分類器權重
\[ \alpha_{t}=\frac{1}{2} \log \frac{1-\epsilon_{t}}{\epsilon_{t}} \]
​ 然後更新樣本權重
\[ \mathcal{D}_{t+1}\left(x^{(i)}\right)=\frac{1}{Z_{t}} \mathcal{D}_{t}\left(x^{(i)}\right) \exp \left[-\alpha_{t} y^{(i)} h_{t}\left(x^{(i)}\right)\right] \]
​ 其中 \(Z_t\) 為歸一化因子
\[ Z_{t}=\sum_{i} \mathcal{D}_{t}\left(x^{(i)}\right) \exp \left[-\alpha_{t} y^{(i)} h_{t}\left(x^{(i)}\right)\right] \]
構建基本分類器的線性組合
\[ f(x)=\sum_{t=1}^{T} \alpha_{t} h_{t}(x) \]
得到最終分類器
\[ H(x)=\operatorname{sign}\left(\sum_{t=1}^{T} \alpha_{t} h_{t}(x)\right) \]

這裡我們可以看到 \(\alpha_t\) 是大於 $\frac{1}{2} $ 的，如果誤分類了，那麼 \(-\alpha_{t} y^{(i)} h_{t}\left(x^{(i)}\right)\) 為大於 0 的數，那麼樣本的權重就會被放大，反之，則會被縮小。並且， \(\epsilon_t\) 越大，\(\alpha_t\) 就越小，即在最終構建強分類器的時候，誤差率越小的弱分類器預測結果所佔比重越高。

演算法推導

思考兩個個問題， \(\alpha_t\) 的公式是怎麼來的？以及權重更新公式是怎麼來的？下面通過公式推導來講解

假設已經經過 \(t-1\) 輪迭代，得到\(f_{t-1}(x)\)，根據前向分佈加法演算法
\[ f_t(x) = f_{t-1}(x) + \alpha_{t}h_t(x) \]
目標是損失函式最小，即
\[ \min{Loss} = \min\sum_{i=1}^{N}exp[-y_i(f_{t-1}(x_i)+\alpha_th_t)] \]
所以，有
\[ \begin{eqnarray}(\alpha_t,h_t(x)) & = & \arg {\min_{\alpha,h}\sum_{i=1}^{N}exp[-y_i(f_{t-1}(x_i)+\alpha_th_t()x_i)]} \\ & = & \arg {\min_{\alpha,h}\sum_{i=1}^{N}w_{t,i}exp[-y_i(\alpha_th_t(x_i))]} \end{eqnarray} \]

\[ w_{t,i} = \exp[-y_if_{t-1}(x_i)] \]

我們先來化簡損失函式
\[ \begin{eqnarray}Loss & = &\sum_{y_i=h_t(x_i)}w_{t,i}exp(-\alpha_t)+\sum_{y_i \ne h_t(x_i)}w_{t,i}exp(\alpha_t) \\ & = & \sum_{i=1}^{N}w_{t,i}(\frac{\sum_{y_i=h_t(x_i)}w_{t,i}}{\sum_{i=1}^{N}w_{t,i}}exp(-\alpha_t)+\frac{\sum_{y_i \ne h_t(x_i)}w_{t,i}}{\sum_{i=1}^{N}w_{t,i}}exp(-\alpha_t)) \end{eqnarray} \]
仔細以看，後面那項 \(\frac{\sum_{y_i \ne h_t(x_i)}w_{t,i}}{\sum_{i=1}^{N}w_{t,i}}\) 就是分類誤差率 \(\epsilon_{t}\)，所以
\[ Loss = \sum_{i=1}^{N}w_{t,i}[(1-\epsilon_t)exp(-\alpha_t)+\epsilon_texp(\alpha_t)] \]
對 \(\alpha_t\) 求偏導
\[ \begin{eqnarray} \frac{\partial Loss}{\partial \alpha_t} & = & \sum_{i=1}^{N}w_{t,i}[-(1-\epsilon_t)exp(-\alpha_t)+\epsilon_texp(\alpha_t)] \end{eqnarray} \]
令 \(\frac{\partial Loss}{\partial \alpha_t} = 0\) ，則
\[ -(1-\epsilon_t)exp(-\alpha_t)+\epsilon_texp(\alpha_t) = 0 \]
推得
\[ \alpha_{t}=\frac{1}{2} \log \frac{1-\epsilon_{t}}{\epsilon_{t}} \]
另，由前向分佈加法演算法
\[ \begin{eqnarray} w_{t,i} & = & \exp[-y_if_{t-1}(x_i)] \\ & = & \exp[-y_i(f_{t-2}(x_i)+\alpha_{t-1}h_{t-1}(x_i))] \\ & = & w_{t-1,i}\exp[\alpha_{t-1}h_{t-1}(x_i)] \end{eqnarray} \]
再加上規範化因子即為演算法中的更新公式。（公式敲的要累死了~~~）

程式碼實現

這裡為了方便起見，我使用了 sklearn 裡面的決策樹，之前使用的時候一直沒發現 sklearn 裡的決策樹可以帶權重訓練 orz。。。決策樹帶權訓練的程式碼我後面再研究研究

from sklearn.tree import DecisionTreeClassifier
def adaboost(X, y, M, max_depth=None):
    """
    adaboost函式，使用Decision Tree作為弱分類器
    引數:
        X: 訓練樣本
        y: 樣本標籤, y = {-1, +1}
        M: 使用 M 個弱分類器
        max_depth: 基學習器決策樹的最大深度
    返回:
        F: 生成的模型
    """
    num_X, num_feature = X.shape
    
    # 初始化訓練資料的權值分佈
    D = np.ones(num_X) / num_X
    
    G = []
    alpha = []
    
    for m in range(M):
        # 使用具有權值分佈 D 的訓練資料集學習，得到基本分類器
        # 使用 DecisionTreeClassifier，設定樹深度為 max_depth
        G_m = DecisionTreeClassifier(max_depth=max_depth)
        # 開始訓練
        G_m.fit(X, y, D)
        # 計算G_m在訓練資料集上的分類誤差率
        y_pred = G_m.predict(X)
        e_m = np.sum(D[y != y_pred])
        
        if e_m == 0:
            break
        
        if e_m == 1:
            raise ValueError("e_m = {}".format(e_m))
            
        # 計算 G_m 的係數
        alpha_m = np.log((1 - e_m) / e_m) / 2
#         print(alpha_m)
        # 更新訓練資料集的權值分佈
        D = D * np.exp(-alpha_m * y * y_pred)
        D = D / np.sum(D)
        # 儲存 G_m 和其係數
        G.append(G_m)
        alpha.append(alpha_m)
    
    # 構建基本分類器的線性組合
    def F(X):
        num_G = len(G)
        score = 0
        for i in range(num_G):
            score += alpha[i] * G[i].predict(X)
        return np.sign(score)
        
    return F

小節

上面介紹了整合學習的一些知識點以及 AdaBoost 的基本原理及實現，下一篇將介紹整合學習中基於 Bagging 的隨機森林(Random Forest)