利用Adaboost提高分类性能

Adaboost为一种集成算法，是对其他算法进行组合的一种方式。

本文将通过单层决策树分类器建立一个Adaboost优化算法，即利用多个弱分类器构建一个强分类器。

弱分类器：分类器性能比随机猜测要略好，但是也不会好太多。

强分类器：分类器性能比随机猜测好很多。

下面结合代码说明Adaboost算法原理和思路：

单层决策树是一种简单的决策树，仅基于单个特征来做决策。

首先加载简单的训练数据。

def loadSimpleData():
    dataMat = np.mat(
        [ [1.0,2.1],
          [2.0,1.1],
          [1.3,1.0],
          [1.0,1.0],
          [2.0,1.0]]
    )
    classLabels = [1.0,1.0,-1.0,-1.0,1.0]
    return dataMat,classLabels

训练数据：训练数据大小为(5, 2)，即 m = 5, n = 2，同时返回的还有每个数据点对应的类别所组成的向量。

为了方便使用，我们首先构造单层决策树的代码：

def buildStump(dataArr, classLabels, D):
    dataMatrix = np.mat(dataArr)
    labelMatrix = np.mat(classLabels).T
    m,n = np.shape(dataArr)
    numSteps = 10.0
    bestStump = {}
    bestCalssEst = np.mat(np.zeros((m,1)))
    minError = math.inf   # 正无穷大
    for i in range(n):  # 遍历所有的特征
        rangeMin = dataArr[ : ,i].min()
        rangeMax = dataArr[ : ,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 = stumpClassify(dataMatrix,i,threshVal,inequal)
                errArr = np.mat(np.ones((m,1)))
                errArr[predictedVals == labelMatrix] = 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
                    bestCalssEst = predictedVals.copy()
                    bestStump[‘dim‘] = i
                    bestStump[‘thresh‘] = threshVal
                    bestStump[‘ineq‘] = inequal
    return bestStump,minError,bestCalssEst

上面代码执行的流程：

该函数传入三个参数：训练数据集（dataArr）, 类别数据集（classLabels）, 每个样本点权重组成的向量（D）。

• 遍历所有特征（本例为两个特征）
  • 计算该特征维度上的取值区间，并根据设定的步长分割得到一系列阈值
  • 遍历每个特征中每个阈值（threshVal）
    • 指定分类的方向（一般为两类）
      • 调用函数stumpClassify得到预测的数据predictedVals（列向量）
      • 计算误差，并结合权重D计算新的权重误差，若比之前保存的最小权重误差小，则更新最小权重误差（minError），保存类别数据（bestCalssEst）和分类情况bestStump（dim：分类维度；threshVal：阈值；inequal：分类方向）：当前决策树即为最佳单层决策树

这是上面用到的预测类别的函数：

def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):
    retArray = np.ones((np.shape(dataMatrix)[0], 1))
    if threshIneq == ‘lt‘:   #根据指定的分类的方向修改数据的类别
        retArray[dataMatrix[ : ,dimen] <= threshVal] = -1.0   # 小于阈值的为-1类
    else:
        retArray[dataMatrix[ : ,dimen] > threshVal] = -1.0    # 大于阈值的为-1类
    return retArray

了解了单层决策树的原理流程后，接下来就是完整的Adaboost算法的实现了：

# 基于单层决策树的AdaBoost训练过程
def adaBoostTrainDS(dataArr, classLabels, numIt = 40):
    weakClassArr = []
    m = np.shape(dataArr)[0]  # 行数
    D = np.mat(np.ones((m,1))/m) # 初始化D
    aggClassEst = np.mat(np.zeros((m,1)))
    for i in range(numIt):
        bestStump,error,classEst = buildStump(dataArr,classLabels,D)
        print(‘D:‘,D.T)
        alpha = float(0.5 * math.log((1.0- error)/max(error,1e-16))) # 避免除数为0溢出
        bestStump[‘alpha‘] = alpha
        weakClassArr.append(bestStump)
        print(‘classEst:‘,classEst.T)
        expon = np.multiply(-1* alpha * np.mat(classLabels).T, classEst)
        D = np.multiply(D, np.exp(expon))
        D = D/D.sum()
        aggClassEst += alpha * classEst
        print(‘aggClassEst:‘,aggClassEst.T)
        aggErrors = np.multiply(np.sign(aggClassEst) != np.mat(classLabels).T,np.ones((m,1)))
        errorRate = aggErrors.sum()/m
        print(‘total error:‘,errorRate,‘\n‘)
        if errorRate == 0: break
    return weakClassArr

代码执行的流程简要如下： 该函数三个输入参数分别为：训练数据集（dataArr）, 类别数据集（classLabels）, 迭代次数（用户指定）

• 初始化权重向量D
• 按照迭代次数循环
  • 调用单层决策树函数buildStump，获得此次迭代分类效果最好（权重误差最小）的分类情况相关数据（权重误差minError，类别数据bestCalssEst，bestStump（dim：分类维度；threshVal：阈值；inequal：分类方向））
  • 根据最小误差计算并更新$\alpha$（分类器的权重值），公式为 $\alpha =\frac{1}{2}ln(\frac{1-\epsilon }{\epsilon })$
  • 将$\alpha$添加到bestStump（字典）中，至此，bestStump中保存四个信息：分类器的权重值$\alpha$，分类维度i，阈值threshVal，分类方向unequal。并将bestStump添加到weakClassArr（保存每次迭代得到的分类器）中
  • 计算并更新D的值： 如果某个样本分类正确，该样本的权重更新为： $D = \frac{D*{e}^{-\alpha}}{Sum(D)}$ 如果某个样本分类错误，该样本的权重更新为： $D = \frac{D*{e}^{\alpha}}{Sum(D)}$ 更新权重向量D的目的在于将正确分类的样本的权重降低而错误分类的样本的权重升高。
  • 累加每个分类器对每个数据点预测类别，并且计算误差，误差为0或者到达指定迭代次数则退出。

以上就是基于单层决策树利用Adaboost算法构建强分类器的过程，当然也可用其他类型的分类器作为弱分类器来构建。