manbetx官方网站

opebet网址购并学习的AdaBoost集成学习的AdaBoost

十月 13th, 2018  |  manbet体育登录

 AdaBoost

  当做出要决定时,大家兴许会见设想吸取多单家而不特是一个人口之见识,机器上吧是如此,这就是合二为一学习之核心思想。使用并方法时有多种形式:可以是例外算法的并轨,也可以是一模一样算法在不同设置下之三合一,还足以是数据集不同部分分配受不同分类器之后的合一。

  由于并学习中地考虑了多只不等之型,一般而言能抱比好之属性,因此在众厚算法性能的场所,集成学习一般是首选。例如,在重重数挖掘的竞技被,获胜的算法一般都是采取并学习将多单模型聚合而变成。

  与单个模型对照,集成学习之老毛病包括:

(1)计算复杂度较生。因为于并学习中需要训练多独模型,所以计算复杂度会有比充分程度的增进;

(2)一般而言,所得的范很麻烦讲。如单个决策树模型很易解释,而鉴于多只裁定树组成的随意森林(random
forest)却休坏容易解释。

  根据基学习器的浮动策略,集成学习的办法可分成两像样:

(1)并行方法(parallel
method),以bagging为重大代表;

(2)顺序方法(sequential
method),以boosting为要代表。

 AdaBoost

  当做出重大决定时,大家可能会见设想吸取多单家而未特是一个人口之见地,机器上也是这般,这就是合二为一学习之着力思想。使用并方法时有多种形式:可以是差算法的合一,也可以是同样算法在不同设置下之并,还可以是数据集不同部分分配给不同分类器之后的融会。

  由于并学习中地考虑了大多单不等的模子,一般而言能得到比较好的性质,因此在多器算法性能的场合,集成学习一般是首选。例如,在无数数码挖掘的较量被,获胜的算法一般还是采取并学习将大半单模型聚合而成为。

  与单个模型对照,集成学习的症结包括:

(1)计算复杂度较充分。因为于并学习着需训练多独模型,所以计算复杂度会生出于生程度之滋长;

(2)一般而言,所得的型很麻烦释。如单个决策树模型很容易解释,而由于多单裁定树组成的妄动森林(random
forest)却不坏容易解释。

  根据基学习器的变迁策略,集成学习之法可分为两近乎:

(1)并行方法(parallel
method),以bagging为要代表;

(2)顺序方法(sequential
method),以boosting为根本代表。

Bagging

  bootstrap
aggregating方法吗叫做bagging方法,是打旧数据集进行随机放回抽样后获得彼此独立的M个新数据集的技艺。新数据集中可以有重的多少,原数汇总之有数据或者不见面当新数据汇总出现。

  于M个数据集建立好后,将分类器算器(可以使用多种不同算法)分别作用为M个数据集,这样就得到了M个模型。当对新数据分类时,就可以采用这M个分类型分类,对结果进行投票,得宗最好多之就凡是最后结果。随机森林是同等种更先进的bagging方法。

  Bagging算法过程如下:

  1. 每轮从老训练集中发放大回地抽取n个训练样本(在训练集中,有些样本或受频繁抽取到,而稍样本或同破都没有为抽中)。共开展M轮抽取,得到M个训练集。(M个训练集之间是互独立的)
  2. 老是用一个教练集得到一个模子,M个训练集一起获得M个模型。(这里连从未切实可行的归类算法或回归艺术,我们得以根据实际问题用不同之归类或回归艺术,如决策树、感知器等)
  3. 对分类问题:将上步得到的M个模型采用投票的艺术取得分类结果;对回归问题,计算上述模型的均值作为最后的结果。(所有模型的首要同样)

Bagging

  bootstrap
aggregating方法为叫做bagging方法,是由原有数据集进行随机放回抽样后获得彼此独立的M个新数据集的技巧。新数据集中可以来再次的多少,原数集中的一对数据或者无会见以初数据汇总出现。

  以M个数据集建立好后,将分类器算器(可以应用多种不同算法)分别作用为M个数据集,这样便获得了M个模型。当对新数据分类时,就可运用即M个分类型分类,对结果开展投票,得宗最好多的即凡是最后结果。随机森林是均等种更上进的bagging方法。

  Bagging算法过程如下:

  1. 每轮从旧训练集中发生放大回地抽取n个训练样本(在训练集中,有些样本或给频繁抽取到,而稍样本或同涂鸦都没为抽中)。共开展M轮抽取,得到M个训练集。(M个训练集之间是相独立的)
  2. 老是用一个教练集得到一个模型,M个训练集齐得M个模型。(这里连没有具体的归类算法或回归艺术,我们好依据现实问题用不同之归类或回归艺术,如决策树、感知器等)
  3. 本着分类问题:将上步得到的M个模型采用投票的主意获取分类结果;对回归问题,计算上述模型的均值作为最终之结果。(所有模型的重要同样)

Boosting

  Boosting是和Bagging相似的一律栽技术,其核心思想是针对同一个教练集训练出不同之弱分类器,然后将这些弱分类器集合起来,构造一个更胜似之末梢分类器。

  所谓弱分类器,意味着分类器的不易比随机猜测略好,但是非会见好不过多。这即意味着当二分类的情形下与世长辞分类器的错误率可能超过50%,而大分类器的错误率就见面小多。

  多只弱分类器的意思并无是据每种分类器都采取了不同的分类算法,而是利用了同分类算法,但是经过训练得有不同的范。例如,使用线性分类器对一维特采集进行分拣,由于训练多少不同,将收获f(x)=2x+3和f(x)=2.5x+2星星独分类型。

   以PAC(概率近似正确)学习框架下,一定得拿弱分类器组装成一个强分类器。PAC
定义了上学算法的强弱:

  • 逝世学习算法—识别错误率小于1/2(即准确率仅于自由猜测略强的求学算法)
  • 愈上算法—识别准确率很高并能够以差不多项式时间外成功的习算法

  Valiant和
Kearns首不好提出了PAC学习型中弱学习算法和大上算法的等价性问题,即随意给定仅比较自由猜测略好的物化学习算法,是否可将该升级也大上算法?
如果两者等价,那么单纯待找到一个比随机猜测略好的辞世学习算法就可以将该提升为胜上到底法
,而无自然寻找很为难获得的强上算法。也就算是这种猜测,让多牛人去设计算法来证实PAC理论的不易。

Boosting

  Boosting是暨Bagging相似的均等种植技术,其核心思想是针对性同一个教练集训练有不同之弱分类器,然后拿这些弱分类器集合起来,构造一个又胜似之末梢分类器。

  所谓弱分类器,意味着分类器的正确性比随机猜测略好,但是未会见好最多。这就算代表当二分类的气象下与世长辞分类器的错误率可能超过50%,而高分类器的错误率就见面逊色多。

  多只弱分类器的意思并无是依每种分类器都采用了不同之分类算法,而是使用了一致分类算法,但是经过训练得有不同的型。例如,使用线性分类器对一维特采集进行归类,由于训练多少不同,将沾f(x)=2x+3和f(x)=2.5x+2少于独分类型。

   在PAC(概率近似正确)学习框架下,一定好拿弱分类器组装成一个强分类器。PAC
定义了就学算法的强弱:

  • 故世学习算法—识别错误率小于1/2(即准确率仅较自由猜测略高之习算法)
  • 强上算法—识别准确率很高并能当差不多项式时间外就的修算法

  Valiant和
Kearns首次等提出了PAC学习型中弱学习算法和大上算法的等价性问题,即随意给定仅比自由猜测略好之弱学习算法,是否好拿其升级也大上算法?
如果双方等价,那么就需要找到一个比随机猜测略好之去世学习算法就好拿其提升也大上到底法
,而不自然寻找很麻烦获的过人上算法。也就算是这种猜测,让广大牛人去设计算法来证明PAC理论的不利。

AdaBoost

  上面提到了针对性PAC模型的怀疑,不过那个丰富一段时间都尚未一个现实的计来兑现这美妙。细节决定成败,再好之争辩也需要中的算法来施行。终于功夫不负有心人,Schapire在1996年提出一个实用之算法真正实现了这个夙愿,它的名叫AdaBoost。AdaBoost把多独例外的决策树用一种植非随机的点子结合起来,表现来震惊的性能!第一,把决策树的准确率大大提高,可以与SVM媲美。第二,速度快,且基本不用调参数。第三,几乎不Overfitting。我估算马上Breiman和Friedman肯定高兴坏了,因为马上着她们提出的CART正在让SVM比下的时刻,AdaBoost让决定树起死回生!Breiman情不自禁地于外的论文里赞扬AdaBoost是极致好的现货方法(off-the-shelf,即“拿下了便足以用”的意思)。

  AdaBoost是adaptive
boosting的缩写,是广大Boosting算法中较为流行的平等栽。

  AdaBoost算法针对不同之训集训练与一个(使用同一算法)基本分类器(弱分类器),然后把这些在不同训练集上得的分类器集合起来,构成一个更强之终极的分类器(强分类器)。理论证明,只要每个弱分类器分类能力比较自由猜测要好,当该个数趋向于无穷个数时,强分类器的错误率将趋于于零。这点可就此直观感觉判断,只要每个分类器的正确率比错误率稍强一点点,当分类器足够多之上,正确的多寡就是会高于错误的数据。

  需要小心都是,AdaBoost训练之享有分类器,在教练集上的正确率都该高于50%,否则是分类器将比较自由猜测还要差,可能根本就是一个不当的分类器,上面的下结论(当分类器足够多的下,正确的数量就是会见超出错误的数)也无成立。

  AdaBoost算法中不同之训集是通过调整每个样本对应的权重实现之。一开始之上每个样本的权重相等,由此训练处一个为主分类器C1。对于C1区划错以及分对的样本,分别增大和削弱多少其权重,再计出C1底权重;重复该操作M轮,以使得权重大的样本还倾向被分类正确,最终得出总分类器。从直观上讲,后面的弱分类器集中处理前面为错分的样本,这样叫分类器犯的荒谬各不相同,因此聚合之后会获取比较好之效应。

opebet网址 1

切切实实经过如下:

  1. 共有N个训练样本
  2. 教练集中之每个样本的权重为W,Wi代表第i只样本的权重系数,W的初始值是1/N
  3. 一路训练M轮,每轮得到得到一个弱分类器C,Cm意味着第m轮子训练后取的弱分类器
  4. 起迭代,计算每个弱分类器的权重,并创新样本的权重系数

4.1.每轮被分类器的加权误差率为:

opebet网址 2

  该误差率也是每轮基本分类器的损失函数,训练之目标是只要损失函数最小。上式中产标m表示第m轱辘训练;上标i表示第i单训练样本;分母值为1。其中εm意味着在第m轮训练中,弱分类器Cm的加权误差率,介于[0,1]之间;
I(Cm(x(i))≠y(i))是一个指令函数,具体如下:

opebet网址 3

4.2.计算弱分类器Cm的权重系数,也就是是Cm于尽算法中的话语权:

opebet网址 4

函数曲线如下:

opebet网址 5

有鉴于此,分类器加权误差率越聊,其权重越老;方误差率超过0.5时不时,权重降低为负值,这吗是我们用放弃错误率在50%之上之分类器的来由。

4.3.创新训练集中每个训练样本的权重系数:

opebet网址 6

由于αm>0,故而exp(-αm)<1,当样本给着力分类器正确分类时,其权重在裁减,反之权重在增大。

4.4.超反至4.1截至迭代完结。

5.到手终极之总分类器,总分类器是由每轮迭代发出的弱分类器综合而来:

opebet网址 7

若是第二分类:

opebet网址 8

  实质上,在总体训练的历程遭到,每轮训练得的弱分类器可能直接会存在分类错误的题目(不论训练了略微轮,生成的么弱分类器都发分类错误),然而整整AdaBoost框架却有或迅速消灭(整个AdaBoost框架的错误率为0)。造成此场景的原故是:

  每轮训练了晚,AdaBoost框架会对样本的权重进行调,该调整之结果是尤为到后被错误分类的样本权重相会愈来愈强。这样交背后,单个弱分类器为了达到较逊色的带权分类误差都见面拿样本权重高的样书分类正确。虽然独自来拘禁,单个弱分类器仍会招致分类错误,但这些为误分类的样书的权重都于逊色,在AdaBoost框架的末尾输出时见面叫眼前是分类的高权重弱分类器“平衡”掉。这样造成的结果就是是,虽然每个弱分类器可能都来分错的范本,然而所有AdaBoost框架却会确保对每个样本进行对分类,从而实现快速消灭。

AdaBoost

  上面提到了针对性PAC模型的猜测,不过那个丰富一段时间都无一个有血有肉的计来实现这良好。细节决定成败,再好的辩护为欲中的算法来施行。终于功夫不负有心人,Schapire在1996年提出一个卓有成效的算法真正实现了这个夙愿,它的名字叫AdaBoost。AdaBoost把多独不等的裁定树用一栽非随机的办法做起来,表现有惊人的性质!第一,把决策树的准确率大大提高,可以同SVM媲美。第二,速度快,且基本不用调参数。第三,几乎不Overfitting。我估摸就Breiman和Friedman肯定喜欢好了,因为就着他俩提出的CART正在给SVM比下去的时光,AdaBoost让决定树起死回生!Breiman情不自禁地在他的论文里赞扬AdaBoost是最为好之现货方法(off-the-shelf,即“拿下了便好就此”的意)。

  AdaBoost是adaptive
boosting的缩写,是众Boosting算法中较为流行的一样栽。

  AdaBoost算法针对不同之训集训练以及一个(使用同一算法)基本分类器(弱分类器),然后把这些在不同训练集及沾的分类器集合起来,构成一个再强之末段之分类器(强分类器)。理论证明,只要每个弱分类器分类能力比较自由猜测要好,当该个数趋向于无穷个数时,强分类器的错误率将趋于于零。这点可以用直观感觉判断,只要每个分类器的正确率比错误率稍强一点点,当分类器足够多的时段,正确的数据就会见超过错误的数量。

  需要专注都是,AdaBoost训练的装有分类器,在训练集上的正确率都应当高于50%,否则是分类器将较自由猜测还要差,可能根本就是一个左的分类器,上面的定论(当分类器足够多的时段,正确的数就见面超越错误的数目)也无树立。

  AdaBoost算法中不同的训练集是通过调整每个样本对应之权重实现之。一开始的下每个样本的权重相等,由此训练处一个基本分类器C1。对于C1私分错以及分对的范本,分别增大和削弱多少其权重,再计出C1的权重;重复该操作M轮,以使得权重大的范本还赞成被分类正确,最终得出总分类器。从直观上说话,后面的弱分类器集中处理前面为错分的范本,这样叫分类器犯的荒谬各不相同,因此聚合之后能够获取比较好的功用。

opebet网址 9

切切实实经过如下:

  1. 共有N个训练样本
  2. 训练集中之每个样本的权重为W,Wi代表第i单样本的权重系数,W的初始值是1/N
  3. 齐训练M轮,每轮得到得到一个弱分类器C,Cm意味着第m车轮训练后取的弱分类器
  4. 始于迭代,计算每个弱分类器的权重,并创新样本的权重系数

4.1.各个轮遭遇分类器的加权误差率为:

opebet网址 10

  该误差率也是每轮基本分类器的损失函数,训练的目标是要损失函数最小。上式中产标m表示第m轮训练;上标i表示第i独训练样本;分母值为1。其中εm意味着以第m车轮训练中,弱分类器Cm的加权误差率,介于[0,1]之间;
I(Cm(x(i))≠y(i))是一个指令函数,具体如下:

opebet网址 11

4.2.计算弱分类器Cm的权重系数,也就是Cm以漫天算法中的话语权:

opebet网址 12

函数曲线如下:

opebet网址 13

由此可见,分类器加权误差率越聊,其权重越怪;方误差率超过0.5常常,权重降低呢负值,这为是咱得放弃错误率在50%上述的分类器的来头。

4.3.更新训练集中每个训练样本的权重系数:

opebet网址 14

由于αm>0,故而exp(-αm)<1,当样本被基本分类器正确分类时,其权重在减小,反之权重在增大。

4.4.超过反到4.1截至迭代终结。

5.沾最终的总分类器,总分类器是出于每轮迭代时有发生的弱分类器综合而来:

opebet网址 15

若是次分拣:

opebet网址 16

  实质上,在方方面面训练的过程遭到,每轮训练得的弱分类器可能直接会在分类错误的题目(不论训练了聊轮,生成的么弱分类器都生分类错误),然而整整AdaBoost框架却发生或迅速消灭(整个AdaBoost框架的错误率为0)。造成此场景的原由是:

  每轮训练结束后,AdaBoost框架会对样本的权重进行调,该调整的结果是进一步到后面被张冠李戴分类的样本权重相会越来越强。这样交背后,单个弱分类器为了上较逊色之带权分类误差都见面管样本权重高之范本分类正确。虽然独自来拘禁,单个弱分类器仍会招致分类错误,但这些为错分类的范本的权重都较逊色,在AdaBoost框架的尾声输出时会为前是分类的高权重弱分类器“平衡”掉。这样造成的结果虽是,虽然每个弱分类器可能还发生分错的样本,然而整整AdaBoost框架却能保证对每个样本进行对分类,从而实现快速消退。

Bagging与Boosting的区别

1.样论选择:

Bagging:每一样车轮的教练集是在初集中发生放大回捎的,从原始集中选出的各轮训练集之间是单独的。

Boosting:每一样轮子的教练集不转换,只是训练集中每个样例在分类器中之权重发生变化。而权值是依据达一致车轮的归类结果开展调整。

2.样例权重:

Bagging:使用都匀取样,每个样例的权重相等

Boosting:根据错误率不断调整样例的权值,错误率越充分则权重越老。

3.预计函数:

Bagging:所有预测函数的权重相等。

Boosting:每个弱分类器都起对应的权重,对于分类误差小之分类器会生重新怪之权重。

4.并行计算:

Bagging:各个预测函数可以相互生成

Boosting:各个预测函数只能挨个生成,因为后一个模型参数需要前面一样车轮模型的结果。

Bagging与Boosting的区别

1.样遵循卜:

Bagging:每一样轱辘的训练集是在初集中发生放大回捎的,从原集中选出的各轮训练集之间是独的。

Boosting:每一样轮子的教练集不转移,只是训练集中每个样例在分类器中的权重发生变化。而权值是因上亦然车轮的分类结果进行调。

2.样例权重:

Bagging:使用都匀取样,每个样例的权重相等

Boosting:根据错误率不断调整样例的权值,错误率越老则权重越老。

3.展望函数:

Bagging:所有预测函数的权重相等。

Boosting:每个弱分类器都有对应的权重,对于分类误差小的分类器会发重新要命之权重。

4.并行计算:

Bagging:各个预测函数可以互相生成

Boosting:各个预测函数只能挨个生成,因为后一个型参数需要前面同车轮模型的结果。

示例

吃得训练集中来10独训练样本:

opebet网址 17

 

 

设若进行3轮迭代,根据地方的介绍:M=3,N=10,基础分类器为决策树。

示例

深受得训练集中发生10独训练样本:

opebet网址 18

 

 

假定进展3轮迭代,根据地方的介绍:M=3,N=10,基础分类器为决策树。

第1轮迭代,M=1

样本权值W1(i)=1/10=0.1,

当选择x<=2为1进行分拣时,[[6],[7],[8]]分错,此时拿走最佳误差率ε1
= 0.300100

分类器

opebet网址 19

α1 = 0.423411

第1轮迭代,M=1

样本权值W1(i)=1/10=0.1,

当选择x<=2为1展开分拣时,[[6],[7],[8]]分错,此时获得最佳误差率ε1
= 0.300100

分类器

opebet网址 20

α1 = 0.423411

第2轮迭代,M=2

新一轱辘的样本权值W2=[0.07144558 
0.07144558  0.07144558  0.07144558  0.07144558  0.07144558  0.16662699 
0.16662699  0.16662699 
0.07144558],上轮分错的[[6],[7],[8]]权值增大,其余减小。

当选择x<=8为1展开分类时,[[3],[4],[5]]分错,此时得最佳误差率ε2
=0.214437

分类器

opebet网址 21

α2 = 0.649193

第2轮迭代,M=2

乍一车轮的样本权值W2=[0.07144558 
0.07144558  0.07144558  0.07144558  0.07144558  0.07144558  0.16662699 
0.16662699  0.16662699 
0.07144558],上轮分错的[[6],[7],[8]]权值增大,其余减小。

当选择x<=8为1展开归类时,[[3],[4],[5]]分错,此时取得最佳误差率ε2
=0.214437

分类器

opebet网址 22

α2 = 0.649193

第3轮迭代,M=3

初一轮子的样本权值W3=[
0.04548182  0.04548182  0.04548182  0.16661719  0.16661719  0.16661719 
0.10607372  0.10607372  0.10607372 
0.04548182],上轮分错的[[3],[4],[5]]权值增大,其余减小。

入选择x>5吗1展开分拣时,[[0],[1],[2],[9]]分错,此时收获最佳误差率opebet网址ε3
=0.182027

分类器

opebet网址 23

α3 = 0.751336

第3轮迭代,M=3

新一轮的样本权值W3=[
0.04548182  0.04548182  0.04548182  0.16661719  0.16661719  0.16661719 
0.10607372  0.10607372  0.10607372 
0.04548182],上轮分错的[[3],[4],[5]]权值增大,其余减小。

当选择x>5为1展开分拣时,[[0],[1],[2],[9]]分错,此时拿走最佳误差率ε3
=0.182027

分类器

opebet网址 24

α3 = 0.751336

总分类器

H(x) =
sign(0.423C1(x)+0.649C2(x)+
0.182C3(x))

总分类器

H(x) =
sign(0.423C1(x)+0.649C2(x)+
0.182C3(x))

代码

  1 MIN_ERR = 0.0001
  2 class MyAdaBoost:  
  3     def __init__(self, x_features, y_labels, classifer):  
  4         #总训练集features
  5         self.x_features = np.array(x_features)
  6         #总训练集labels, 取值 -1, 1
  7         self.y_labels = np.array(y_labels)
  8         #共N个训练集
  9         self.N = self.x_features.shape[0]
 10         #基础分类器,分类器的预测结果返回-1或1
 11         self.classifer = classifer  
 12         #初始化每个训练集的加权值
 13         self.W = np.ones((self.N, 1)) / self.N
 14          
 15  
 16     def train(self, M:'迭代次数'=3):  
 17         #每次迭代形成的分类器
 18         self.C = {}  
 19         #分类器权重
 20         self.alpha = {}  
 21  
 22         #迭代M次
 23         for i in range(M):
 24             #本轮分类器
 25             self.C[i] = self.classifer(self.x_features, self.y_labels)
 26             #本轮分类器的加权误差率
 27             err = self.C[i].train(self.W)  
 28             #self.C[i] 的权重
 29             self.alpha[i] = 1 / 2 * np.log((1 - err) / err)  
 30             #分类器C[i]的预测结果
 31             pred_y = np.array(self.C[i].pred(self.x_features))
 32             #flatten返回一个叠成一维的数组,预测结果与实际结果相乘,相同为1,相异为-1 
 33             pred_compare = pred_y.flatten() * self.y_labels.flatten()
 34             #重新计算训练样本的权值
 35             Z = self.W.flatten() * np.exp(-self.alpha[i] * pred_compare)
 36             self.W = (Z / Z.sum()).reshape(self.N, 1)
 37             
 38             print('m%d'%(i+1))
 39             print('w =', self.W.flatten())
 40             print('value = %f' % self.C[i].item_value)
 41             print('err = %f' % err)
 42             print('alpha = %f' % self.alpha[i])
 43             print('-' * 100)
 44             
 45             if err <= MIN_ERR:
 46                 break
 47             
 48     def pred(self, test_x):  
 49         sums = 0
 50         for i in self.C:
 51             sums += self.C[i].pred(test_x) * self.alpha[i]
 52             
 53         return np.sign(sums)
 54 
 55 class DumpClassifier:
 56     def __init__(self, x_features, y_labels):
 57         self.x_features = x_features
 58         self.y_features = y_labels
 59         #分裂项的下标
 60         self.item_idx = 0
 61         #分裂项的值
 62         self.item_value = 0
 63         #训练集的权值
 64         self.W = None
 65         
 66         self.threshIneq = 'lt'
 67     
 68     def train(self, W):
 69         self.W = W
 70         #最小误差值
 71         minErr = 9999999
 72         #分裂项缓存,存储分裂项下标和分裂项值组成的元组
 73         descItem = {}
 74         
 75         #按列循环
 76         for idx in range(self.x_features.shape[1]):
 77             #根据这一列的每个值尝试对数据集进行拆分
 78             for value in self.x_features.T[idx]:          
 79                 if (idx, value) in descItem:
 80                     minErr = descItem[(idx, value)]
 81                     continue
 82                 
 83                 #寻找最佳决策树
 84                 thisErr_gt = self.getThisErr(idx, value, 'gt')
 85                 thisErr_lt = self.getThisErr(idx, value, 'lt')
 86                 thisErr = min(thisErr_gt, thisErr_lt)
 87                 if thisErr < minErr:
 88                     self.item_idx, self.item_value, minErr = idx, value, thisErr
 89                     self.threshIneq = 'lt' if thisErr_lt < thisErr_gt else 'gt'
 90                 
 91                 descItem[(idx, value)] = minErr
 92         
 93         print(self.threshIneq)
 94         return minErr
 95 
 96     def getThisErr(self, idx, value, threshIneq):
 97         thisErr = MIN_ERR
 98         #循环所有训练集,取得最佳分裂值,i表示第i个训练样本
 99         for i in range(self.x_features.shape[0]):
100             x, y = self.x_features[i], y_labels[i]
101             y_pred = self._pred(x, idx, value, threshIneq)
102             if y_pred != y[0]:
103                 thisErr += self.W[i]
104                 
105         return thisErr     
106                 
107                         
108     def _pred(self, x, item_idx, item_value, threshIneq):
109         if threshIneq == 'lt':
110             return 1 if x[item_idx] <= item_value else -1
111         else:
112             return 1 if x[item_idx] > item_value else -1
113             
114 #         #连续型数据
115 #         if item_idx == 0:
116 #             if threshIneq == 'gt':
117 #                 return 1 if item_value >= x[item_idx] else -1
118 #             else:
119 #                 return 1 if item_value < x[item_idx] else -1
120 #         #离散型数据
121 #         else:
122 #             return 1 if item_value == x[item_idx] else -1
123 
124     def pred(self, x_features):
125         y = []
126         for x in x_features:
127             y.append([self._pred(x, self.item_idx, self.item_value, self.threshIneq)])
128             
129         return y

 

 控制台结果:

opebet网址 25

  


 

参考文献:

《机器上导论 第二本子》

《使用机器上》

 http://www.cnblogs.com/chaosimple/p/4029795.html

http://www.360doc.com/content/14/1109/12/20290918\_423780183.shtml

http://www.cnblogs.com/esefcu0320—-/p/6045612.html

 作者:我是8位的

 出处:http://www.cnblogs.com/bigmonkey

 本文因习、研究和享用为主,如需转载,请联系我,标明作者和出处,非商业用途! 

 

代码

  1 MIN_ERR = 0.0001
  2 class MyAdaBoost:  
  3     def __init__(self, x_features, y_labels, classifer):  
  4         #总训练集features
  5         self.x_features = np.array(x_features)
  6         #总训练集labels, 取值 -1, 1
  7         self.y_labels = np.array(y_labels)
  8         #共N个训练集
  9         self.N = self.x_features.shape[0]
 10         #基础分类器,分类器的预测结果返回-1或1
 11         self.classifer = classifer  
 12         #初始化每个训练集的加权值
 13         self.W = np.ones((self.N, 1)) / self.N
 14          
 15  
 16     def train(self, M:'迭代次数'=3):  
 17         #每次迭代形成的分类器
 18         self.C = {}  
 19         #分类器权重
 20         self.alpha = {}  
 21  
 22         #迭代M次
 23         for i in range(M):
 24             #本轮分类器
 25             self.C[i] = self.classifer(self.x_features, self.y_labels)
 26             #本轮分类器的加权误差率
 27             err = self.C[i].train(self.W)  
 28             #self.C[i] 的权重
 29             self.alpha[i] = 1 / 2 * np.log((1 - err) / err)  
 30             #分类器C[i]的预测结果
 31             pred_y = np.array(self.C[i].pred(self.x_features))
 32             #flatten返回一个叠成一维的数组,预测结果与实际结果相乘,相同为1,相异为-1 
 33             pred_compare = pred_y.flatten() * self.y_labels.flatten()
 34             #重新计算训练样本的权值
 35             Z = self.W.flatten() * np.exp(-self.alpha[i] * pred_compare)
 36             self.W = (Z / Z.sum()).reshape(self.N, 1)
 37             
 38             print('m%d'%(i+1))
 39             print('w =', self.W.flatten())
 40             print('value = %f' % self.C[i].item_value)
 41             print('err = %f' % err)
 42             print('alpha = %f' % self.alpha[i])
 43             print('-' * 100)
 44             
 45             if err <= MIN_ERR:
 46                 break
 47             
 48     def pred(self, test_x):  
 49         sums = 0
 50         for i in self.C:
 51             sums += self.C[i].pred(test_x) * self.alpha[i]
 52             
 53         return np.sign(sums)
 54 
 55 class DumpClassifier:
 56     def __init__(self, x_features, y_labels):
 57         self.x_features = x_features
 58         self.y_features = y_labels
 59         #分裂项的下标
 60         self.item_idx = 0
 61         #分裂项的值
 62         self.item_value = 0
 63         #训练集的权值
 64         self.W = None
 65         
 66         self.threshIneq = 'lt'
 67     
 68     def train(self, W):
 69         self.W = W
 70         #最小误差值
 71         minErr = 9999999
 72         #分裂项缓存,存储分裂项下标和分裂项值组成的元组
 73         descItem = {}
 74         
 75         #按列循环
 76         for idx in range(self.x_features.shape[1]):
 77             #根据这一列的每个值尝试对数据集进行拆分
 78             for value in self.x_features.T[idx]:          
 79                 if (idx, value) in descItem:
 80                     minErr = descItem[(idx, value)]
 81                     continue
 82                 
 83                 #寻找最佳决策树
 84                 thisErr_gt = self.getThisErr(idx, value, 'gt')
 85                 thisErr_lt = self.getThisErr(idx, value, 'lt')
 86                 thisErr = min(thisErr_gt, thisErr_lt)
 87                 if thisErr < minErr:
 88                     self.item_idx, self.item_value, minErr = idx, value, thisErr
 89                     self.threshIneq = 'lt' if thisErr_lt < thisErr_gt else 'gt'
 90                 
 91                 descItem[(idx, value)] = minErr
 92         
 93         print(self.threshIneq)
 94         return minErr
 95 
 96     def getThisErr(self, idx, value, threshIneq):
 97         thisErr = MIN_ERR
 98         #循环所有训练集,取得最佳分裂值,i表示第i个训练样本
 99         for i in range(self.x_features.shape[0]):
100             x, y = self.x_features[i], y_labels[i]
101             y_pred = self._pred(x, idx, value, threshIneq)
102             if y_pred != y[0]:
103                 thisErr += self.W[i]
104                 
105         return thisErr     
106                 
107                         
108     def _pred(self, x, item_idx, item_value, threshIneq):
109         if threshIneq == 'lt':
110             return 1 if x[item_idx] <= item_value else -1
111         else:
112             return 1 if x[item_idx] > item_value else -1
113             
114 #         #连续型数据
115 #         if item_idx == 0:
116 #             if threshIneq == 'gt':
117 #                 return 1 if item_value >= x[item_idx] else -1
118 #             else:
119 #                 return 1 if item_value < x[item_idx] else -1
120 #         #离散型数据
121 #         else:
122 #             return 1 if item_value == x[item_idx] else -1
123 
124     def pred(self, x_features):
125         y = []
126         for x in x_features:
127             y.append([self._pred(x, self.item_idx, self.item_value, self.threshIneq)])
128             
129         return y

 

 控制台结果:

opebet网址 26

  


 

参考文献:

《机器上导论 第二版本》

《使用机器上》

 http://www.cnblogs.com/chaosimple/p/4029795.html

http://www.360doc.com/content/14/1109/12/20290918\_423780183.shtml

http://www.cnblogs.com/esefcu0320—-/p/6045612.html

 作者:我是8位的

 出处:http://www.cnblogs.com/bigmonkey

 本文为习、研究暨分享为主,如要转载,请联系自己,标明作者和出处,非商业用途! 

 

标签:, , ,

Your Comments

近期评论

    功能


    网站地图xml地图