#coding=utf-8

from numpy import *

def loadSimpleData():

    dataMat = matrix([[1. , 2.1],

        [2. , 1.1],

        [1.3 , 1.],

        [1. , 1.],

        [2. , 1.]])

    classLabels = [1.0,1.0,-1.0,-1.0,1.0]

    return dataMat, classLabels

#训练出单个弱分类器，输出预测值

def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):

    #初始化预测结果为array数组，样本数行，1列，值为1

    retArry = ones((shape(dataMatrix)[0],1))

    if threshIneq == 'lt':

        #dataMatrix[:,dimen]表示为某一特征列的所有行，即存为列向量

        retArry[dataMatrix[:,dimen] <= threshVal] = -1.0

    else:

        retArry[dataMatrix[:,dimen] > threshVal] = -1.0

    return retArry

#D是权重向量，此函数功能是训练出最佳的单个的弱分类器，决策桩。返回最佳的弱分类器详情参数（第几维决策桩，阀值，不等于号，错误率，预测结果）

def buildStump(dataArr,classLabels,D):

    dataMatrix = mat(dataArr)

    labelMat = mat(classLabels).T

    m,n = shape(dataMatrix)

    numSteps = 10.0#在特征所有可能值上遍历

    bestStump = {}#用于存储单层决策树的信息

    bestClasEst = mat(zeros((m,1)))

    minError = inf

    for i in range(n):#遍历所有特征

        rangeMin = dataMatrix[:,i].min()

        rangeMax = dataMatrix[:,i].max()

        stepSize = (rangeMax - rangeMin) / numSteps

        for j in range(-1,int(numSteps)+1):

            for inequal in ['lt','gt']:

                threshVal = (rangeMin + float(j) * stepSize)#得到阀值

                #根据阀值分类，弱分类器结果预测分类结果放入predictedVals

                predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)

                errArr = mat(ones((m,1)))

                errArr[predictedVals == labelMat] = 0

                weightedError = D.T * errArr#不同样本的权重是不一样的

                #print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal, weightedError)

                if weightedError < minError:

                    minError = weightedError

                    #bestClasEst为最佳分类结果

                    bestClasEst = predictedVals.copy()

                    bestStump['dim'] = i

                    bestStump['thresh'] = threshVal

                    bestStump['ineq'] = inequal

    return bestStump,minError,bestClasEst

#此函数控制迭代次数为默认40次（函数中计算总分类器错误率为0时break），训练总分类器weakClassArr，列表里存放元素为每个弱分类器（阀值，不等于号，第几维）

def adaBoostTrainDS(dataArr,classLabels,numIt=40):

    weakClassArr = []

    m =shape(dataArr)[0]

    D = mat(ones((m,1))/m)#初始化所有样本的权值一样

    aggClassEst = mat(zeros((m,1)))#每个数据点的估计值

    for i in range(numIt):

        bestStump,error,classEst = buildStump(dataArr,classLabels,D)

        #计算alpha，max(error,1e-16)保证没有错误的时候不出现除零溢出

        #alpha表示的是这个分类器的权重，错误率越低分类器权重越高

        alpha = float(0.5*log((1.0-error)/max(error,1e-16)))

        bestStump['alpha'] = alpha

        weakClassArr.append(bestStump)

        #classEst 存放弱分类器 预测出的最佳分类结果，为array数组形式，列向量。

        #classLabels存放的是 实际的分类结果（列表形式），mat强制转换为矩阵后再转置为列向量。

        expon = multiply(-1*alpha*mat(classLabels).T,classEst) #exponent for D calc, getting messy

        D = multiply(D,exp(expon))                              #Calc New D for next iteration

        D = D/D.sum()

        #calc training error of all classifiers, if this is 0 quit for loop early (use break)

        aggClassEst += alpha*classEst

        #print "aggClassEst: ",aggClassEst.T

        '''

>>> ones((2,1))!=mat([[-1],[1]])

matrix([[ True],

        [False]], dtype=bool)

>>> multiply(ones((2,1))!=mat([[-1],[1]]),ones((2,1)))

matrix([[ 1.],

        [ 0.]])

'''

        #sign(aggClassEst) != mat(classLabels).T 存放：总分类器的预测结果和实际分类结果作比较后的bool值，预测对为True，预测错为False。

        #必须与对应元素相一致的array数组相乘得到矩阵形式的列向量，值为0,1

        aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1)))

        errorRate = aggErrors.sum()/m

        print "total error: ",errorRate

        if errorRate == 0.0:

            break

    return weakClassArr

#dataToClass 表示要分类的点或点集，预测点或点集的分类结果

def adaClassify(datToClass,classifierArr):

    dataMatrix = mat(datToClass)#do stuff similar to last aggClassEst in adaBoostTrainDS

    m = shape(dataMatrix)[0]

    aggClassEst = mat(zeros((m,1)))

    for i in range(len(classifierArr)):

        #总分类器中的每个弱分类器是已知的最佳弱分类器，参数都已定好。直接调用stumpClassify函数进行分类，并输出预测结果classEst

        classEst = stumpClassify(dataMatrix,classifierArr[i]['dim'],\

                                 classifierArr[i]['thresh'],\

                                 classifierArr[i]['ineq'])#call stump classify

        #利用预测结果以及弱分类器的alpha值，算出单个的结果，然后循环算出总分类器f(x)值

        aggClassEst += classifierArr[i]['alpha']*classEst

        print aggClassEst

    #取结果值得符号

    return sign(aggClassEst)

def main():

    #加载数据，赋初始值样本权重为相等的 1/样本数

    dataMat,classLabels = loadSimpleData()

    D = mat(ones((5,1))/5)

    #classifierArr存放：总分类器，元素为弱分类器的详细情况

    classifierArr = adaBoostTrainDS(dataMat,classLabels,30)

    t = adaClassify([0,0],classifierArr)

    print t 

if __name__ == '__main__':

    main()