AdaBoost推导及实现

AdaBoost 属于集成学习算法的一种。集成学习通过构建多个学习任务。结构框架如图所示

集成学习通过多个分类器进行结合，因而大多数情况下拥有较好的泛化性能，以AdaBoost为例，其集成方法各有千秋：可以是同一算法在不同设置下集成；也可以是在不同数据集上集成，一般数据进行抽样训练。
不同的学习器要有一定的准确性，又要有差异性。
如图是Ada的模型：

右边矩形代表不同权重下的数据集（同一数据集）

AdaBoost既可以用于分类问题，也可以用于回归问题。
关于如何推导出算法的简洁公式：（二分类为例）
二分类问题 $y\in \{1,-1\}$ 和真实的取值函数$f(x)$, 假设基础分类器的错误率为$\epsilon$,对于每个分类器$h_i(x)$ 有

$$P[h_i(x)\ne f(x)]=\epsilon$$
原则上若超过半数以上的分类器分类正确，则认为集成分类就是正确的
集成分类器是其线性组合：
$$H(x)=sign \bigg( \sum_{t=1}^{T}h_i(x)\biggr)$$
而在AdaBoost中，有一种加权线性模型：
$$H(x)= \sum_{t=1}^{T}\alpha_i h_i(x)$$
其中 $\alpha_i$为各自分类器的权重。
在分布 $D$上，（D为分类器权重向量），定义的最小化损失函数$L_{exp}$的表达式为（exp为 exponential loss function 即最小化损失函数）：
$$L_{exp}(H|D)=e^{-f(x)H(x)}$$
一个多元复合函数，要求其最小化，则求偏导；这里需要对目标函数也就是 $H(x)$求偏导：
$H(x)包含取值为1的H_1和取值为-1的H_2$,因而链式求偏导过程为：
$$e^{-f(x)H(x)}:\begin{cases} f(x):\begin{cases}1,\\-1\end{cases}\\ H(x):\begin{cases}H_1(x)\\H_2(x)\end{cases} \end{cases}$$

那么：

$\frac{\partial L_{exp}(H|D)}{\partial H(x)}=\frac {\partial e^{-f(x)H(x)}}{\partial H(x)}=\frac {\partial e^{-f_1(x)H_1(x)}}{\partial H_1(x)}+\frac {\partial e^{-f_{-1}(x)H_{-1}(x)}}{\partial H(x)}\\=e^{f_1{(x)H_1(x)}}[-f_1(x)]{\frac {\partial H(x)}{\partial H_1(x)}}+e^{f_{-1}{(x)H_{-1}(x)}}[-f_{-1}(x)]{\frac {\partial H(x)}{\partial H_{-1}(x)}}$

因为$f_{1}(x)=1$与$f_{-1}(x)=-1$,代入上式得：

$\frac{\partial L_{exp}(H|D)}{\partial H(x)}=-e^{-H_1(x)}P(f(x)=1|x)+e^{H_{-1}(x)}P(f(x)=-1|x)$

令其为0求解：
$e^{-H_1(x)}P(f(x)=1|x)=e^{H_{-1}(x)}P(f(x)=-1|x) \\ \Rightarrow \frac{e^{H_{-1}(x)}}{e^{-H_{1}(x)}}=\frac{P(f(x)=1|x)}{P(f(x)=-1|x)}=e^{H_1(x)+H_{-1}(x)}=e^{2H(x)} \\两边取对数: \\\Rightarrow H(x)=\frac{1}{2}ln \frac{P(f(x)=1|x)}{P(f(x)=-1|x)}$

值得注意的是 $H(x)$一开始由基于算法初始数据分布而来。

因为：$H_t(x)=\alpha_tf(x)$,那么：

$$\frac{\partial L_{exp}(\alpha_tf(x)|D_t)}{\partial \alpha_t}=\frac{1}{2}ln \frac{1-\epsilon}{\epsilon} \Leftarrow权重更新公式$$

算法获得$H_{t-1}$后，下一轮学习的$h_t$将修正$H_{t-1}$的错误：

$$L_{exp}((H_{t-1}+h_t)|D)=e^{-f(x)[H_{t-1}(x)+h_t]}=e^{-f(x)H_{t-1}(x)}*e^{-f(x)h_t(x)}$$

对后一项进行二阶泰勒展开：
因为：二阶泰勒展开：$e^x=1-x+\frac{x^2}{2}$

故上式得：$e^{-f(x)H_{t-1}(x)}*[1-f(x)h_t(x)+\frac{f_(x)^2h_t(x)^2}{2}]$

又因为 $f_(x)^2=h_t(x)^2=1 \Rightarrow e^{-f(x)H_{t-1}(x)}*[1-f(x)h_t(x)+\frac{1}{2}]$

$argmax=e^{-f(x)H_{t-1}(x)}f(x)h_t(x)$

$argmax=\frac{e^{-f(x)H_{t-1}(x)}}{E_x\sim D[e^{-f(x)H_{t-1}(x)}]}f(x)h_t(x)$

那么每次权重$D$的迭代：

$$D_{t+1}=\frac{D_t(x)e^{-f(x)H_{t}(x)}}{Sum(D(x))}=\frac{D_t(x)e^{-\alpha_tf(x)h_{t}(x)}}{Sum(D(x))}$$

下面是代码，公式所有代码实现均在train方法里面：注意一点就是：第一个分类器是基于算法初始数据分布而来（和猜差不多？），此后迭代的生成$h_t$和$\alpha_t$，而后生成$D_t$

class AdaBoost(object):
    def __init__(self,data_matrix,labels,iter_nums):
        self.X = np.matrix(data_matrix)
        self.y = np.matrix(labels)
        samples = np.shape(data_matrix)[0]    
        self.D = np.mat(np.ones((samples,1))/samples)
        self.iter = range(iter_nums)

    def stumpClassfily(self,data_matrix,dimen,thresh_val,thresh_ineq):
        rest_arr = np.ones((np.shape(data_matrix)[0],1))
        if thresh_ineq is 'lt':
            rest_arr[data_matrix[:,dimen]<=thresh_val] = -1.0
        else:
            rest_arr[data_matrix[:,dimen]>thresh_val] = -1.0
        return rest_arr

    def buildStump(self):
        samples,features = np.shape(self.X)
        num_steps = 10
        best_stump = {}
        best_class_estimate = np.mat(np.zeros((samples,1)))
        min_error = np.inf

        for i in range(features):
            range_min = self.X[:,i].min()
            range_max = self.X[:,i].max()
            step_size = (range_max-range_min)/num_steps
            for j in range(-1,num_steps+1):
                for inequal in ['lt','gt']:
                    thresh_val = (range_min+float(j)*step_size)
                    predict_val = self.stumpClassfily(self.X,i,thresh_val,inequal)
                    error_matrix = np.matrix(np.ones((samples,1)))
                    error_matrix[predict_val==self.y.T] = 0
                    weight_error = self.D.T * error_matrix

                    if weight_error < min_error:
                        min_error = weight_error
                        best_class_estimate = predict_val.copy()
                        best_stump['dim'] = i
                        best_stump['thresh'] = thresh_val
                        best_stump['ineq'] = inequal
        return best_stump,min_error,best_class_estimate


    def train(self):
        weak_class_arr = []
        samples = np.shape(self.X)[0]
        aggravete_class_est = np.mat(np.zeros((samples,1)))
        for rounds in self.iter:
            best_stump,error,class_est = self.buildStump()
            alpha = float(0.5*np.log((1.0-error)/max(error,1e-16)))
            best_stump['alpha'] = alpha
            weak_class_arr.append(best_stump)
            expon_loss_func = np.multiply(-1*alpha*self.y.T,class_est)
            self.D = np.multiply(self.D,np.exp(expon_loss_func))
            self.D = self.D/self.D.sum()
            aggravete_class_est += alpha*class_est
            agg_errors_matrix = np.multiply(np.sign(aggravete_class_est)!=self.y.T,
                                            np.ones((samples,1)))
            error_rate = agg_errors_matrix.sum()/samples
            if error_rate is 0.0:break

        return weak_class_arr


class Predcitor(AdaBoost):
    def __init__(self,data_matrix,classifyer_set):
        self.X = data_matrix
        self.classifyers = classifyer_set


    def predict(self):
        samples = np.shape(self.X)[0]
        agg_class_est = np.mat(np.zeros((samples,1)))
        for classifyer in self.classifyers:
            class_est = self.stumpClassfily(self.X,classifyer['dim'],
                                            classifyer['thresh'],
                                            classifyer['ineq'])
            agg_class_est += classifyer['alpha']*class_est
        return np.sign(agg_class_est)