详细解释adaboost算法,下面关于adaboost算法的描述中,错误的是

　　基本Adaboost算法将几个弱分类器组合成一个强分类器。

　　AdaBoost是英文‘Adaptive Boosting’(自适应增强)的缩写，由Yoav Freund和Robert Schapire于1995年提出。

　　其自适应性在于，被前一个弱分类器错误分类的样本的权重(样本的对应权重)将被加强，权重更新后的样本将被用于再次训练下一个弱分类器。在每一轮训练中，用群体(样本群体)训练一个新的弱分类器，产生新的样本权重和弱分类器的话语权，迭代直到达到预定的错误率或达到指定的最大迭代次数。总体——样本——个体三者间的关系需要搞清除

　　总n .样本：{ni} i从1到m个体：如果n1=(1，2)，则样本n1中有两个个体。

　　优点：

　　(1)高精度分类器。

　　(2)提供了框架，可以使用多种方法构建弱分类器。

　　(3)简单，不需要特征筛选。

　　(4)不用担心过度拟合。实际应用：

　　(1)用于两个或多个分类中。

　　(2)特征选择

　　(3)分类性状的基线。

　　算法原理：(1)初始化训练数据(每个样本)的权重分配：如果有n个样本，每个训练样本点在开始时会被赋予相同的权重：1/n。

　　(2)训练弱分类器。在具体的训练过程中，如果一个样本已经被准确分类，那么在构造下一个训练集时，它的权重就会降低。相反，如果一个样本点没有被准确分类，它的权重将会提高。同时获得弱量词对应的话语权。然后，用更新后的样本集训练下一个分类器，整个训练过程迭代进行。

　　(3)将训练得到的弱分类器组合成强分类器。每一个弱分类器的训练过程结束后，分类错误率小的弱分类器话语权更大，对最终分类函数起更大的决定性作用，而分类错误率大的弱分类器话语权更小，对最终分类函数起更小的决定性作用。换句话说，错误率低的弱分类器在最终的分类器中所占的比重更大，反之亦然。

　　流量：第一步：

　　初始化训练数据(每个样本)的权重分布。每个训练样本在初始化时被赋予相同的权重w=1/N。n是样本总数。

　　D1代表第一次迭代中每个样本的权重。W1表示第一次迭代中第一个样本的权重。

　　n是样本总数。第二步：进行多次迭代，m=1，2…M。m表示迭代次数。

　　a)使用权重分布为Dm(m=1，2，3…N)的训练样本集进行学习，得到弱分类器。

　　该公式表明第m次迭代中的弱分类器将样本x分类为-1或1。那么根据什么准则得到弱分类器？.

　　准则：这个弱分类器的误差函数最小，即错误样本对应的权值之和最小。

　　b)计算弱分类器Gm(x)的话语权，话语权am表示Gm(x)在最终分类器中的重要性。其中em为上一步中的m(误差函数值)。

　　这个公式随着em的减小而增大。即错误率小的分类器在最终的分类器中更重要。

　　c)更新训练样本集的权重分布。进行下一次迭代。其中，错误分类样本的权重会增加，正确分类样本的权重会减少。

　　DM是下一次迭代的样本的权重，Dm 1，I是下一次迭代的第I个样本的权重。

　　其中yi表示第I个样本对应的类别(1或-1)，Gm(xi)表示弱分类器对样本xi的分类(1或-1)。yi*Gm(xi)的值如果成对则为1，如果不成对则为-1。其中Zm是归一化因子，因此对应于所有样本的权重之和为1。

　　这个公式不难。仔细看仔细想。从00到59000迭代后，合并弱分类器。

　　首先，

　　然后，添加一个符号函数，用来求值的正负。该值大于0，为1。小于0，也就是-1。等于0，也就是0。得到最终的强分类器G(x)。

　　第三步(关于权重、话语权、弱量词准则的公式，想了解更多可以看看。如果用的话，知道以上内容就够了)

　　利用前向分布加法模型(简单来说就是一起求解n个问题，一次求解一个问题，然后在此基础上求解下一个问题，迭代n次)，adaboost算法可以看作公式的最小值。当tn样本N对应正确分类时，fm是前M个分类器的组合(这里乘以1/2，因为博主看的文章的am是1/2log(~~)。这个无所谓，无非是多1/2，少1/2。

　　然后，假设已经确定了前m-1个相关参数。通过简化公式E，我们可以得到：

　　其中是常数。

　　然后，

　　其中Tm是正确分类样品的重量，Mm是错误分类样品的重量。公式不难，看几遍就明白了。

　　到现在可以看出，最小化E其实就是最小化。

　　这个公式是什么？看前面，这是找弱分类器的标准！

　　然后在得到弱分类器ym后，可以进一步推导am和样本的权重。这里给出am的推导过程(手写，有烂字)，其中为

　　这个图中，最右边的是“exp(-am/2)*1”，太乱了(—_—)

　　最后am不是1/2，所以无所谓。因为这里定义的fm是乘以1/2。

　　实现(Python 2.7)额外: Adaboos算法实现。

　　#编码：UTF-8 from _ _ future _ _ import division import numpy as NP import scipy as sp from weak classify import weak from sign import * class ADABC:def _ _ init _ _(self，X，y，weak=weak): X是一个N*M的矩阵较弱的是一个弱分类器的类它应该有一列火车（自我w)方法将权重参数传递给训练需要调用~~~方法，去训练权值参数预解码(测试集)方法返回由一或-1构成的y ~ ~ ~方法，返回y(y的值为-1或1) 统计学习方法 ###初始化数据##X是样本点自我X=np.array(X)##列优先排列Y是样本对应的类别排成一个行向量self.y=np.array(y).展平(1)#判断数据维度的列数是否一样（数据是否对应)断言自我. X.shape[1]==self.y.size #弱分类器自我更弱=更弱的自己。总和=NP。零(自我。y .形状)#初始化权值每个样本的权值为1/样本数自我W=np.ones((自我X.shape[1]，1))。展平(1)/自身十.形状[1]自我Q=0 #打印自我Wdef火车(self，M=4):“‘M是最大类别（第M个)弱分类器的下标，其实就是迭代的次数，#初始化弱分类器字典（空)自我G={}#弱分类器的话语权自我。alpha={ } for I in range(M):self .G.setdefault(i) #{0:无，I:None } self设置默认值(I)# 0:无，i:None}for i in range(M): #用样本初始化弱分类器自我g[I]=自我。更弱的（自我. x，self.y)#调用火车方法，训练弱分类器，同时计算最小误差率e=自我G[i].训练（自我. w)#打印自我G[i].自我评价.G[i].t_b，e#计算弱分类器镀锌铁的话语权（根据公式)self alpha[I]=1/2 * NP。log((1-e)/e)#打印自身alpha[I]#计算弱分类器镀锌铁对样本的分类结果sg=自我G[i].预解码(自身. X)#计算归一化因子（计算样本权值时，保证权值之和为1)Z=自我w * NP。exp(-self。阿尔法[我]*自我。y * SG。transpose())#更新样本的权值自我W=(Z/Z.sum())。展平(1)#记录迭代次数（从0开始)自我Q=i#print self.finalclassifer(i)，=========#判断组合起来的强分类器的效果，如果没有错分，不在迭代如果自我。finalclassifer(I)==0:print I 1，弱分类器足以使错误为0breakdef finalclassifer(self，t): 将第一个到第t个弱分类器组合起来（跟踪adaboost算法算法强分类器组合公式)#组合成强分类器，并直接计算出其对样本的分类结果（没有用唱歌函数计算前)self.sums=self.sums self .G[t].预解码(自身. x).flatten(1)* self alpha[t]#打印自我。总数#用符号对分类器计算出的值进行判别pre _ y=sign(self。sums)# sums=NP。零(自我。y . shape)# for I in range(t ^ 1):# sums=sums self .G[i].预解码(自身. x).flatten(1)* self alpha[I]# print sums # pre _ y=sign(sums)#对分类结果计算对比，统计不相同个数，如果全分对则为0t=(pre_y！=self.y).总和()返回tdef pred(self，test _ set):test _ set=NP。数组(测试集)#判断数据大小是否一样断言test_set.shape[0]==self .x . shape[0]sums=NP。零((test _ set。形状[1]，1).扁平化(1) #计算分类器训练样本的结果因为我在范围内（自我10 . Q 1):总和=总和本身G[i].测试集.扁平化(1)*自身alpha[I]打印总数#用符号函数判断类别pre _ y=sign(sums)return pre _ yadaBoost.py:测试adaboost算法算法算法

　　#编码：UTF-8从_ _ future _ _ import division导入numpy作为NP导入scipy作为sp从adaBoost导入adaabc从弱分类导入弱 示例0:此示例来自统计学习方法 X=np.array([0，1，2，3，4，5，6，7，8，9]).shape(1，-1)y=np.array([1，1，1，-1，1，1，1，1，1，-1]).transpose()a=ADABC(X，y)a.train(5) 示例1:这是一个二维示例 X=np.array([[0.55，4.4]，[1.1，2.8]，[1.85，1.95]，[3.15，1.7]，[4，2.7]，[3.75，3.95]，[2.8，4.4]，[2.35，3.2]，[3transpose()y=np.array([[-1]，[-1]，[-1]，[-1]，[-1])其余的两个模块如下：

　　**weakclassify.py:**弱分类器

　　# coding:UTF-8 from _ _ future _ _ import division import numpy as NP import scipy as sp class weak c:def _ _ init _ _(self，X，y):X是一个N*M的矩阵是一个长度M的向量是训练案例的数量这个弱分类器是一个决策问题这只是一个基本的例子统计学习方法自我X=NP。数组(X)自身。y=NP。数组(y)自身.n=自我. X.shape[0]def train(self，W，steps=100):W是一个普通长度向量 # print Wmin=1000000000.0t _ val=0；t _ point=0；t _ b=0；自我W=np.array(W)for i in range(self .N):q，err=self.findmin(i，1，steps)if(errmin):min=errt _ val=Qt _ point=it _ b=1对于范围内的我(自己).N):q，err=self.findmin(i，-1，steps)if(errmin):min=errt _ val=Qt _ point=it _ b=-1 self . t _ point=t _ point self。t _ b=t _ b打印自己。t _ val，self。t _ point，self。t _ return mindef find min(self，I，b，steps):t=0now=self。餐前列车(自身。x，I，t，b).transpose()err=np.sum(现在！=self.y)*self .w)#立即打印PGD=0 buttom=NP。最小(自我).X[i，]up=NP。最大值(自我.X[i，mins=1000000 minst=0st=(up-buttom)/NP中t的步数。arange(buttom，up，st):now=self .x，I，t，b).转置()#立即打印。形状，自我.W.shape，(现在！=self.y).shape，self.y.shapeerr=np.sum(现在！=self.y)*self .w)if err mins:mins=err minst=treturn minst，minsdef predintrain(self，test_set，I，t，b):test_set=np.array(test_set).重塑（自我. n，-1)gt=NP。ones((NP。数组(test _ set)).shape[1]，1))#print np.array(test_set[i，]*b)t*bgt[test_set[i，]*bt*b]=-1return gtdef pred(self，test _ set):test _ set=NP。数组(测试集).重塑（自我. n，-1)t=NP。ones((NP。数组(test _ set)).shape[1]，1))t[test_set[self.t_point，]* self。t _ bself。t _ val * self。t _ b]=-1 return tadaboost_test.py:符号函数

　　将numpy作为NP导入将scipy作为sp导入警告# NP。seterr(all= raise )def sign(x):# print x，============ # print ==================== q=NP。零(NP。数组(x).shape)q[x=0]=1q[x0]=-1返回q实验结果：得到了四个弱分类器，4个弱分类器组合后，分类错误率为0。

　　如：3.763 0 1 表示，一条在x等于3.763的位置的直线（弱分类器),0表示3.763在x轴上，1表示大于3.763为类别1,小于为类别-1.

　　虾米的四行三列的数据，用训练后的四的个弱分类器，求三个测试样本的值。最后的-1,-1,1。是将其组合成强分类器后，判断得到的样本分类。

　　个人见解，难免有疏漏，欢迎讨论。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。