Adaboost算法

Adaboost算法

引言

元算法

自举汇聚法

Adaboost算法

代码

总结

1. 有么有想过这个问题，当我们在做一个决定的时候，听从一个专家的建议好还是听从多个专家的意见好，显而易见，综合多个专家的意见，再做出相应的决定。
   把专家作为一个分类器，多个专家就作为多个分类器，从而就引出了接下来的要讲的元算法，提高分类性能。
2. 元算法：我们将不同的分类器组合起来，而这种组合结果则别 被称为集成方法或元算法。
   有三种形式：
   
   1. 不同算法的集成
   2. 同一算法在不同设置下的集成
   3. 数据集不同部分分配给不同分类器之后的集成
3. 自举汇聚法（bagging方法）：在原始数据集选择S次后得到S个新数据集的一种技术，新数据集的大小相等，每一个数据集都是通过在原始数据集中随机选择一个样本进行替换而得到的，这里的替换就意味着可以多项的选择同一样本，这一性质允许新的数据集中可以有重复的值，而原始数据集的某些值，在新界中则不在出现。
4. Adaboost算法：训练数据中的每一个样本，并赋予其一个权重，这些权重构成了向量D，一开始，这些权重都初始化成相等的值，首选在训练数据上训练出了弱分类器并计算该分类上午错误率，然后在同一数据集上再次训练弱分类器，在分类器的第二次训练当中，将会重新调整每个样本的权重，其中第一次分对的样本上午权重会降低，而第一次分错的样本的权重会提高，为了从所有分类器中得到最终的分类结果，Adaboost为每一个分类器的错误率进行计算的，其中错误ε的定义为
   $$ε=\frac{未正确分类的样本数目}{所有样本数目}$$
   而alpha的计算公式如下：
   $$α={\frac{1}{2} }ln({\frac{1-ε}{ε}})$$
   　计算出alpha值之后，可以对权重向量D进行更新，以是的那些正确分类的样本的权重降低而错分样本的权重升高。
   　如果某个样本被正确分类，那么该样本的权重改为
   　
   
   　如果某个样本被分错，那么该样本的权重改为
   
   计算出D之后吗AdaBoost又开始进入下一轮迭代，AdaBoost算法会不断重复训练和调节权重的过程，直到训练错误为0或者弱分类器的数目达到用户的指定数目。
   以单层决策树为例，构建单层决策树，简单来说就是按照每一个特征来划分二叉树针对每一个特征值，从最小到最大依次分左右孩子求误差，但是误差值就是通过乘以一个加权数据集进行的

    AdaBoost算法伪代码：
    对每次迭代：
        找到最佳的单层决策树
        将最佳单层决策树加入到单层决策树数组
        计算alpha
        计算新的权重向量D
        更新累计类别估计值
        如果错误率等于0，则退出循环

前边的AdaBoost算法是进行训练的
测试算法：基于AdaBoost分类，每个弱分类器的结果以其对应的alpha值作为权重，所有这写弱分类器的结果加权求和就得了最后的结果
5. 代码

# coding=utf-8

from numpy import *
import numpy as np
import pylab as pl

def loadSimpData():
    dataMat = mat([[1. , 2.1],
                   [2. , 1.1],
                   [1.3, 1. ],
                   [1. , 1. ],
                   [2. , 1. ]])
    classLable = [1.0, 1.0, -1.0, -1.0, 1.0]
    return dataMat, classLable

def stumpClassify(dataMatrix, dimen, threshVal, threshIneq):
    retArray = ones((shape(dataMatrix)[0], 1))
    if threshIneq == 'It':
        retArray[dataMatrix[:, dimen] <= threshVal] = -1.0#小于等于这一值分为-1类
    else:
        retArray[dataMatrix[:, dimen] > threshVal] = -1.0
    return retArray

#就是按照每一个特征来分二叉树，针对每一个特征值从最小到最大依次分左右孩子求误差值
def buildStump(dataArr, classLable, D):
    dataMatrix = mat(dataArr)
    LableMat = mat(classLable).T
    m, n = shape(dataMatrix)
    numstep = 10.0
    bestStump = {}
    bestClassEst = mat(zeros((m, 1)))#最佳分类标签
    minError = inf
    for i in range(n):
        rangeMin = dataMatrix[:, i].min()
        rangeMax = dataMatrix[:, i].max()
        stepsize = (rangeMax-rangeMin)/numstep#适合步长
        for j in range(-1, int(numstep)+1):#特征值从最小到最大
            for inequal in ['It', 'Ig']:#左右孩子
                threshVal = (rangeMin + float(j)*stepsize)#一小步
                #print "threshVal:",threshVal
                predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)#子树的标签
                errArr = mat(ones((m, 1)))
                #print "predictedVals:",predictedVals
                errArr[predictedVals == LableMat] = 0#误差
                #print "errArr:",errArr
                weigthedErroer = D.T*errArr
                #print weigthedErroer
                if weigthedErroer < minError:
                    minError = weigthedErroer
                    bestClassEst = predictedVals.copy()
                    bestStump['dim'] = i
                    bestStump['thresh'] =  threshVal
                    bestStump['ineq'] = inequal
    return bestStump, minError, bestClassEst
#循环numIt次来找不同的权重alpha，直到错误率为零为止
def adaBoostTrainDs(dataArr, classLable, numIt = 30):
    weakClassArr  = []
    m, n =  shape(dataArr)
    D = mat(ones((m, 1))/m)
    aggClassEst = mat(zeros((m, 1)))
    for i in range(numIt):
        bestStump, error, ClassEst = buildStump(dataArr, classLable, D)
        #print "D.T:", D.T
        #求alpha的值
        alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))
        bestStump['alpha'] = alpha
        weakClassArr.append(bestStump)
        #更新D这个权值向量
        expon = multiply(-1*alpha*mat(classLable).T, ClassEst)
        D = multiply(D, exp(expon))
        D = D/D.sum()
        #求总错误率
        aggClassEst += alpha*ClassEst
        aggErrors = multiply(sign(aggClassEst) != mat(classLable).T, ones((m, 1)))
        errorRate = aggErrors.sum()/m
        #print  errorRate
        if errorRate == 0:
            break
    return weakClassArr

#对测试数据进行预测
def adaClassify(testArr, weakClass):
    testMat = mat(testArr)
    m = shape(testMat)[0]
    aggClassEst = mat(zeros((m,1)))
    for i in range(len(weakClass)):
        #print  weakClass
        classEst = stumpClassify(testMat, weakClass[i]['dim'], weakClass[i]['ineq'], weakClass[i]['thresh'])
        aggClassEst += weakClass[i]['alpha']*classEst
        #print aggClassEst
    return sign(aggClassEst)

def main():
    dataArr, classLable=loadSimpData()
    weakClass = adaBoostTrainDs(dataArr, classLable)
    testArr = [[0,0]]
    lable = adaClassify(testArr, weakClass)
    print lable
if __name__ == "__main__":
    main()

1. 总结：简单得多总结说明一下这个算法，
   对于一个弱分类器来说，是提高他分类性能非常好的工具，弱分类器就拿单层决策树来说，单层决策树是拿一个特征值来为分类的依据，是非常不准确的分类器，也就是前边说的弱分类器，如何提高呢？首先给样本一个相同的权重，在这个权重先计算出一个错误率最小的分类标准，计算出alpha，然后根据样本分类正确与否降低还是提高这个权重，再次循环，给每一个弱分类器一个权重，然后经过无数次之后，把这多个弱分类器的权重叠加起来，得到最终的弱分类器，用此来计算分类