AdaBoost算法实例详解

AdaBoost算法其实很精炼,算法流程也好理解,但是看了算法的解释版本之后,什么前向分布算法,什么指数损失函数之后有点迷糊了。抛开这些理论性的推导不谈(其实是因为能力有限),通过例子直观的了解AdaBoost算法的计算过程。


简要叙述一下AdaBoost算法的主要过程:

AdaBoost为每个数据样本分配权重,权重符合概率分布,初始权重符合均匀分布,串行训练M个模型,依据每轮训练的模型的错误率(被误分类样本的权重之和)确定当前模型在最终模型中的权重,以及更新训练样本的权重,误分类样本权重升高,分类正确的样本权重降低。

下图的算法流程来自于《统计学习方法》。


下面通过具体的实例来理解AdaBoost算法的流程,例子来自于《统计学习方法》。

第一轮迭代:

此时得到的组合模型中只有一个 ,此时 的分类结果就是最终模型的分类结果。第一轮迭代中6,7,8(6,7,8指的是x的值,不是指的序号)被误分类。此时得到的组合模型在训练数样本上的预测结果如下:

X

y

分类结果

0

1

0.4236

0.4236

1

正确

1

1

0.4236

0.4236

1

正确

2

1

0.4236

0.4236

1

正确

3

-1

-0.4236

-0.4236

-1

正确

4

-1

-0.4236

-0.4236

-1

正确

5

-1

-0.4236

-0.4236

-1

正确

6

1

-0.4236

-0.4236

-1

错误

7

1

-0.4236

-0.4236

-1

错误

8

1

-0.4236

-0.4236

-1

错误

9

-1

-0.4236

-0.4236

-1

正确

其中sign符号函数如下:

第二轮迭代:

第二轮迭代中3,4,5被误分类,此时得到的最终模型是前两轮模型的线性组合。那么在当前的组合条件下 的分类结果是怎样的?

X

y

分类结果

0

1

0.4236

0.6496

1.0732

1

正确

1

1

0.4236

0.6496

1.0732

1

正确

2

1

0.4236

0.6496

1.0732

1

正确

3

-1

-0.4236

0.6496

0.226

1

错误

4

-1

-0.4236

0.6496

0.226

1

错误

5

-1

-0.4236

0.6496

0.226

1

错误

6

1

-0.4236

0.6496

0.226

1

正确

7

1

-0.4236

0.6496

0.226

1

正确

8

1

-0.4236

0.6496

0.226

1

正确

9

-1

-0.4236

-0.6496

-1.0732

-1

正确

第三轮迭代:

第三轮迭代中0,1,2,9被误分类,此时得到的最终模型是前三轮模型的线性组合。那么在当前的组合条件下 的分类结果是怎样的?

X

y

分类结果

0

1

0.4236

0.6496

-0.7514

0.3218

1

正确

1

1

0.4236

0.6496

-0.7514

0.3218

1

正确

2

1

0.4236

0.6496

-0.7514

0.3218

1

正确

3

-1

-0.4236

0.6496

-0.7514

-0.5254

-1

正确

4

-1

-0.4236

0.6496

-0.7514

-0.5254

-1

正确

5

-1

-0.4236

0.6496

-0.7514

-0.5254

-1

正确

6

1

-0.4236

0.6496

0.7514

0.9774

1

正确

7

1

-0.4236

0.6496

0.7514

0.9774

1

正确

8

1

-0.4236

0.6496

0.7514

0.9774

1

正确

9

-1

-0.4236

-0.6496

0.7514

-0.3218

-1

正确

经过三轮迭代之后,在训练集上的错误率为0。


python实现的AdaBoost算法如下,代码来源于《机器学习实战》。

# coding:utf-8

import numpy as np


def loadSimpData():
    dataMat = [
        [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


def stumpClassify(dataMatrix, dimen, threshval, threshIneq):
    """
    单层决策树分类决策函数,根据指定特征,指定特征的划分阈值,指定特征的划分条件(大于或者小于)构建决策树
    :param dataMatrix: 数据矩阵
    :param dimen: 分支特征索引编号,按照每个特征进行节点分支
    :param threshval: 分支阈值
    :param threshIneq: 分支类别(大于或者小于)
    :return: 返回分类结果
    """
    retArray = np.ones(shape=(dataMatrix.shape[0], 1))  # 初始化所有样本的分类结果为+1
    if threshIneq == 'lt':
        retArray[dataMatrix[:, dimen] <= threshval] = -1.0  # 将第dimen个特征小于threshval的样本标记为-1
    else:
        retArray[dataMatrix[:, dimen] > threshval] = -1.0  # 将第dimen个特征大于threshval的样本标记为+1
    return retArray


def buildStump(dataArr, classLabels, D):
    """
    遍历决策树的所有特征,所有特征的划分阈值,所有特征的划分条件,寻找最佳单层决策树桩(只有一层的决策树)
    :param dataArr: 数据样本
    :param classLabels: 数据样本标签
    :param D: 数据样本权重
    :return: 最佳单层决策树分类信息、最低错误率、最优分类结果
    """
    dataMatrix = np.mat(dataArr)
    labelMat = np.mat(classLabels).T
    m, n = dataMatrix.shape
    numSteps = 10.0  # 为了寻找最优的划分点,总共尝试的次数
    bestStump = {}
    bestClasEst = np.mat(np.zeros(shape=(m, 1)))
    minError = np.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)  # 计算决策树的分支阈值,当j=-1或j=numSteps + 1时,是单分支决策树
                predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)  # 计算在当前分支阈值条件下,决策树的分类结果
                errArr = np.mat(np.ones(shape=(m, 1)))  # errArr矩阵用于保存决策树的预测结果
                errArr[predictedVals == labelMat] = 0   # 将errArr矩阵中被当前决策树分类正确的样本对应位置的值置为0
                weightedError = D.T * errArr  # 计算分类错误率(按位相乘并求和),错误率=所有分类错误样本的权重求和
                # print("split: dimension %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (
                # i, threshVal, inequal, weightedError))
                if weightedError < minError:  # 如果误差率降低,保存最佳分类方法的相关信息
                    minError = weightedError    # 更新最低误差的数值
                    bestClasEst = predictedVals.copy()  # 更新最低误差时对应决策树的预测结果
                    bestStump['dim'] = i  # 记录最佳分类特征索引编号
                    bestStump['thresh'] = threshVal  # 记录最佳分类特征的分支阈值
                    bestStump['ineq'] = inequal  # 记录最佳分类条件
    return bestStump, minError, bestClasEst


def adaBoostingTrainDS(dataArr, classLabels, numIter=40):
    """
    训练AdaBoost集成模型
    :param dataArr: 输入样本数据
    :param classLabels: 样本数据标签
    :param numIter: 训练迭代次数
    :return: 每轮迭代的最佳弱决策树信息(特征索引编号、分类阈值、分类条件、分类器权重alpha)
    """
    dataArr = np.mat(dataArr)
    weakClassArr = []   # 用于记录各个弱分类器的信息
    m = dataArr.shape[0]  # 训练样本数量
    D = np.mat(np.ones(shape=(m, 1)) / m)  # 向量D用来保存样本权重,初始权重相等
    aggClassEst = np.mat(np.zeros(shape=(m, 1)))  # 最终得到的分类函数
    for i in range(numIter):
        bestStump, error, classEst = buildStump(dataArr, classLabels, D)  # 最佳决策树信息(特征编号,阈值,分支条件)、错误率、分类结果
        # print("D: ", D.T)
        alpha = float(0.5 * np.log((1 - error) / max(error, 1e-16)))  # 基于当前弱分类器的分类错误率计算该分类器的最终决策权重
        bestStump['alpha'] = alpha
        weakClassArr.append(bestStump)
        # print("classEst: ", classEst.T)

        # 对应统计学习方法中公式8.3、8.4、8.5
        expon = np.multiply(-1 * alpha * np.mat(classLabels).T, classEst)  # 更新样本权重,分类错误的样本权重增加,分类正确的样本权重减少
        D = np.multiply(D, np.exp(expon))
        D = D / D.sum()  # 将D归一化为一个概率分布,D中元素的和为1
        aggClassEst += alpha * classEst  # 根据权重整合弱分类器,就是将每个样本对应弱分类器的分类结果乘以对应的alpha然后求和,然后使用sign进行符号化
        # print("aggClassEst: ", aggClassEst.T)
        # print("np.sign -> ", np.sign(aggClassEst) != np.mat(classLabels).T)
        aggErrors = np.multiply(np.sign(aggClassEst) != np.mat(classLabels).T, np.ones(shape=(m, 1)))  # 统计集成后的模型预测错误的样本数量
        errorRate = aggErrors.sum() / m  # 计算错误率
        print("total error: ", errorRate)
        if errorRate == 0.0:  # 直到aggClassEst对全部样本预测正确为止
            break
    return weakClassArr, aggClassEst


def adaBoostingClassify(dataToClassify, classifierArr):
    """
    使用训练好的AdaBoost集成模型进行预测
    :param dataToClassify: 数据样本
    :param classifierArr: 训练得到的AdaBoost弱模型以及模型对应的权重alpha
    :return: 返回数据集的分类结果
    """
    dataMatrix = np.mat(dataToClassify)  # 待预测的输入数据
    m = dataMatrix.shape[0]
    aggClassEst = np.mat(np.zeros(shape=(m, 1)))  # 最终分类器的分类结果
    for i in range(len(classifierArr)):  # 遍历所有的弱分类器
        classEst = stumpClassify(dataMatrix, classifierArr[i]["dim"], classifierArr[i]["thresh"],
                                 classifierArr[i]["ineq"])  # 获取每个弱分类器的预测结果
        aggClassEst += classifierArr[i]["alpha"] * classEst  # 线性累加所有弱分类器的结果
        # print("aggClassEst: ", aggClassEst)
    return np.sign(aggClassEst)  # 输出最终分类结果,累加结果符号化


if __name__ == '__main__':
    dataMat, labelMat = loadSimpData()
    D = np.mat(np.ones(shape=(5, 1)) / 5)
    # print(D)
    # 计算每轮迭代的最佳决策树分类方法
    print("#" * 80)
    bestStump, minError, bestClasEst = buildStump(dataMat, labelMat, D)
    print(bestStump)
    print(minError)
    print(bestClasEst)

    # 训练得到的一些列弱分类器信息
    print("#" * 80)
    classifyArr, aggClassEst = adaBoostingTrainDS(dataMat, labelMat, numIter=9)
    print(classifyArr)
    print(aggClassEst)

    # 测试adaBoosting算法
    print("#" * 80)
    testSet = np.array(
        [
            [0.5, 1.0],
            [1.5, 2.0],
            [0.5, 1.1],
            [0.0, 1.0],
            [1.0, 2.0],
            [0.0, 0.0]
        ]
    )
    classifierResult = adaBoostingClassify(testSet, classifyArr)
    print(classifierResult)

 

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读