关闭

【转】AdaBoost--从原理到实现

标签: AdaBoost
254人阅读 评论(0) 收藏 举报
分类:

一.引入

         对于Adaboost,可以说是久闻大名,据说在Deep Learning出来之前,SVM和Adaboost是效果最好的 两个算法,而Adaboost是提升树(boosting tree),所谓“提升树”就是把“弱学习算法”提升(boost)为“强学习算法”(语自《统计学习方法》),而其中最具代表性的也就是Adaboost了,貌似Adaboost的结构还和Neural Network有几分神似,我倒没有深究过,不知道是不是有什么干货


二.过程

        (from PRML)

         这就是Adaboost的结构,最后的分类器YM是由数个弱分类器(weak classifier)组合而成的,相当于最后m个弱分类器来投票决定分类,而且每个弱分类器的“话语权”α不一样。

         这里阐述下算法的具体过程:

         1.初始化所有训练样例的权重为1 / N,其中N是样例数

         2.for m=1,……M:

               a).训练弱分类器ym(),使其最小化权重误差函数(weighted error function):

                                               

               b)接下来计算该弱分类器的话语权α:

                                                 

               c)更新权重:

                                           

                             其中Zm:

                                                 

                             是规范化因子,使所有w的和为1。(这里公式稍微有点乱)

             3.得到最后的分类器:

                              

三.原理


             可以看到整个过程就是和最上面那张图一样,前一个分类器改变权重w,同时组成最后的分类器
             如果一个训练样例 在前一个分类其中被误分,那么它的权重会被加重,相应地,被正确分类的样例的权重会降低
             使得下一个分类器 会更在意被误分的样例,那么其中那些α和w的更新是怎么来的呢?
             下面我们从前项分步算法模型的角度来看看Adaboost:
             直接将前项分步加法模型具体到adaboost上:
                                  
              其中 fm是前m个分类器的结合
                                   
              此时我们要最小化E,同时要考虑α和yl,
              但现在我们假设前m-1个α和y都已经fixed了:那么
                                   
               其中,可以被看做一个常量,因为它里面没有αm和ym:
               接下来:
                                   
               其中Tm表示正分类的集合,Mm表示误分类的集合,这一步其实就是把上面那个式子拆开,没什么复杂的东西
               然后就是找ym了,就是最小化下式的过程,其实就是我们训练弱分类器
                                                
               有了ym,α也就可以找了,然后继续就可以找到更新w的公式了(注意这里得到的w公式是没有加规范化因子Z的公式,为了计算方便我们加了个Z进去)
               因为这里算出来直接就是上面过程里的公式,就不再赘述了,有兴趣你可以自己算一算         

   

四.实现

               终于到实现了,本次实现代码基本基于《统计学习方法》,比如有些符号(弱分类器是G(x),训练样例的目标是y而不是上文所述的t)差异
          
              
[python]
  1. # coding: UTF-8  
  2. from __future__ import division  
  3. import numpy as np  
  4. import scipy as sp  
  5. from weakclassify import WEAKC  
  6. from dml.tool import sign  
  7. class ADABC:  
  8.     def __init__(self,X,y,Weaker=WEAKC):  
  9.         ''''' 
  10.             Weaker is a class of weak classifier 
  11.             It should have a    train(self.W) method pass the weight parameter to train 
  12.                                 pred(test_set) method which return y formed by 1 or -1 
  13.             see detail in <统计学习方法> 
  14.         '''  
  15.         self.X=np.array(X)  
  16.         self.y=np.array(y)  
  17.         self.Weaker=Weaker  
  18.         self.sums=np.zeros(self.y.shape)  
  19.         self.W=np.ones((self.X.shape[1],1)).flatten(1)/self.X.shape[1]  
  20.         self.Q=0  
  21.         #print self.W  
  22.     def train(self,M=4):  
  23.         ''''' 
  24.             M is the maximal Weaker classification 
  25.         '''  
  26.         self.G={}  
  27.         self.alpha={}  
  28.         for i in range(M):  
  29.             self.G.setdefault(i)  
  30.             self.alpha.setdefault(i)  
  31.         for i in range(M):  
  32.             self.G[i]=self.Weaker(self.X,self.y)  
  33.             e=self.G[i].train(self.W)  
  34.             #print self.G[i].t_val,self.G[i].t_b,e  
  35.             self.alpha[i]=1/2*np.log((1-e)/e)  
  36.             #print self.alpha[i]  
  37.             sg=self.G[i].pred(self.X)  
  38.             Z=self.W*np.exp(-self.alpha[i]*self.y*sg.transpose())  
  39.             self.W=(Z/Z.sum()).flatten(1)  
  40.             self.Q=i  
  41.             #print self.finalclassifer(i),'==========='  
  42.             if self.finalclassifer(i)==0:  
  43.   
  44.                 print i+1," weak classifier is enough to  make the error to 0"  
  45.                 break  
  46.     def finalclassifer(self,t):  
  47.         ''''' 
  48.             the 1 to t weak classifer come together 
  49.         '''  
  50.         self.sums=self.sums+self.G[t].pred(self.X).flatten(1)*self.alpha[t]  
  51.         #print self.sums  
  52.         pre_y=sign(self.sums)  
  53.         #sums=np.zeros(self.y.shape)  
  54.         #for i in range(t+1):  
  55.         #   sums=sums+self.G[i].pred(self.X).flatten(1)*self.alpha[i]  
  56.         #   print sums  
  57.         #pre_y=sign(sums)  
  58.         t=(pre_y!=self.y).sum()  
  59.         return t  
  60.     def pred(self,test_set):  
  61.         sums=np.zeros(self.y.shape)  
  62.         for i in range(self.Q+1):  
  63.             sums=sums+self.G[i].pred(self.X).flatten(1)*self.alpha[i]  
  64.             #print sums  
  65.         pre_y=sign(sums)  
  66.         return pre_y 

看train里面的过程和上文 阐述的一模一样,finalclassifier()函数是用来判断是否已经无误分类的点 的
当然这里用的Weak Classifier是比较基础的Decision Stump,是根据x>v和x<v来分类的,这个代码稍微烦一点,就不贴到这里了,在DML里也有
先试验下《统计学习方法》里面那个最简单的例子:

可以看到也是三个分类器就没有误分点了,权值的选择也是差不多的
其中后面那个-1 表示大于threshold分为负类,小于分为正类。1则相反


加一些其它数据试试:

结果:
  
我们把图画出来就是:





0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:6924次
    • 积分:136
    • 等级:
    • 排名:千里之外
    • 原创:7篇
    • 转载:1篇
    • 译文:0篇
    • 评论:1条
    文章存档
    最新评论