Adaboost算法

最新推荐文章于 2024-03-17 20:24:20 发布
最新推荐文章于 2024-03-17 20:24:20 发布
阅读量170 收藏 1
点赞数
分类专栏： 机器学习 学生 python 文章标签： 算法 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42479155/article/details/103822644
版权
学生 同时被 3 个专栏收录
112 篇文章 0 订阅
订阅专栏
python
74 篇文章 2 订阅
订阅专栏
机器学习
53 篇文章 0 订阅
订阅专栏

Adaboost算法

集成学习概述

集成学习算法定义

  • 集成学习(Ensemble learning)就是讲若干个弱分类器通过一定策略组合后产生一个强分类器。弱分类器(weak Classifier)指的就是那些分类准确率只比随机猜测好一点的分类器。而强分类器(strong Classifier)的分类准确率会高很多，这里的弱和强是相对的，弱分类器也叫做基分类器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gEJDogFz-1578039599583)(/home/ach/.config/Typora/typora-user-images/image-20200103151902690.png)]

  • 分类：

    bagging

    boosting

bagging（装袋）

  • bagging方法又叫做自举汇聚法(boostrap aggregating),是一种根据均匀概率分布从数据集中重复抽样(有放回)的技术，每个数据集和原始数据集大小相等，由于新数据集的每一个样本都是从原数据集合中有放回随机抽样出来的，所以每个数据集中可能有重复的值，而原始数据集中的某些样本可能根本就没有出现在新数据集中

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M8qcVehe-1578039599585)(/home/ach/.config/Typora/typora-user-images/image-20200103152923402.png)]

  • 有放回的随机抽样：自主采样法(Bootstap sampling),也就是说对于m个样本的原始数据集，每次随机选取一个样本放回采样集合中，然后这个样本重新放回，再进行下一次随机抽样，直到采样集合中样本数量达到m，这样一个采样集合就构建好了，重复过程，生成n个采样集合

  • 将n个采样集合，分别进行训练，得到n个弱分类器，根据每个结果进行组合，得到强分类器

  • 降低弱分类器的方差

boosting(提升)

  • 迭代过程，用来自适应的改变训练样本的分布，使得弱分类器聚焦到那些很难分类的样本上，它的做法是给每一个训练样本赋予一个权重，在每一轮训练中自动调整权重

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03eeK0yc-1578039599585)(/home/ach/.config/Typora/typora-user-images/image-20200103153545741.png)]

  • 组合策略

    1. 平均法：

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Alltc62K-1578039599586)(/home/ach/.config/Typora/typora-user-images/image-20200103153643025.png)]

    2. 投票法：

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vcTYyp3O-1578039599587)(/home/ach/.config/Typora/typora-user-images/image-20200103153713147.png)]

    3. 学习法：

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UGTcaD7X-1578039599587)(/home/ach/.config/Typora/typora-user-images/image-20200103153822956.png)]

Adaboost算法(自适应提升算法)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JIwmajVC-1578039599588)(/home/ach/.config/Typora/typora-user-images/image-20200103153935339.png)]

  • 收集数据：可以使用任意方法
    准备数据：依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。
    当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。
    作为弱分类器，简单分类器的效果更好。
    分析数据：可以使用任意方法。
    训练算法：AdaBoost 的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
    测试算法：计算分类的错误率。
    使用算法：通SVM一样，AdaBoost 预测两个类别中的一个。如果想把它应用到多个类别的场景，那么就要像多类 SVM 中的做法一样对 AdaBoost

  • 优点：泛化（由具体的、个别的扩大为一般的）错误率低，易编码，可以应用在大部分分类器上，无参数调节。

    缺点：对离群点敏感。

    适用数据类型：数值型和标称型数据

案例一：自适应算法实现

  • 导入数据：

    def load_sim_data():
    """
    测试数据，
    :return: data_arr   feature对应的数据集
            label_arr  feature对应的分类标签
    """
    data_mat = np.matrix([[1.0, 2.1],
                          [2.0, 1.1],
                          [1.3, 1.0],
                          [1.0, 1.0],
                          [2.0, 1.0]])
    class_labels = [1.0, 1.0, -1.0, -1.0, 1.0]
    return data_mat, class_labels

  • 算法测试：将符合条件的数据转化,测试是否有某个值小于或者大于我们正在测试的阈值,如果大于某个阈值就是错误的

    def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    """
    (将数据集，按照feature列的value进行 二分法切分比较来赋值分类)
    :param data_mat: Matrix数据集
    :param dimen: 特征的哪一个列
    :param thresh_val: 特征列要比较的值
    :param thresh_ineq:
    :return: np.array
    """
    ret_array = np.ones((np.shape(data_mat)[0], 1))
    # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    if thresh_ineq == 'lt':# 假设左边比较一下
        ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    else:# 假设右边比较一下
        ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    return ret_array

  • 单层决策树的实现：最优化单层决策树

    # 这个算法是为了寻找最好的单层决策树
def build_stump(data_arr, class_labels, D):
    """
    得到决策树的模型 (这个比较重要，需要看懂）
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param D: 最初的特征权重值
    :return: best_Stump    最优的分类器模型
            min_error     错误率
            best_class_est  训练后的结果集
    """
    data_mat = np.mat(data_arr)
    label_mat = np.mat(class_labels).T

    m, n = np.shape(data_mat)
    num_steps = 10.0
    best_stump = {}
    best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    # 无穷大
    min_err = np.inf
    for i in range(n):
        range_min = data_mat[:, i].min()
        range_max = data_mat[:, i].max()
        step_size = (range_max - range_min) / num_steps
        for j in range(-1, int(num_steps) + 1):
            for inequal in ['lt', 'gt']:
                thresh_val = (range_min + float(j) * step_size)
                predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
                err_arr = np.mat(np.ones((m, 1)))
                err_arr[predicted_vals == label_mat] = 0
                # 这里是矩阵乘法
                weighted_err = D.T * err_arr
                '''
                dim            表示 feature列
                thresh_val      表示树的分界值
                inequal        表示计算树左右颠倒的错误率的情况
                weighted_error  表示整体结果的错误率
                best_class_est    预测的最优结果 （与class_labels对应）
                '''
                # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
                #     i, thresh_val, inequal, weighted_err
                # ))
                if weighted_err < min_err:
                    min_err = weighted_err
                    best_class_est = predicted_vals.copy()#可以保存的结果集储存
                    best_stump['dim'] = i# 第i列
                    best_stump['thresh'] = thresh_val# 阈值
                    best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    # print(best_stump)
    return best_stump, min_err, best_class_est
# print(np.mat(np.ones((5,1))/5))#赋值相同的权重
# [[0.2]
#  [0.2]
#  [0.2]
#  [0.2]
#  [0.2]]
# print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))

  • 构建自适应算法

    def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    """
    adaBoost训练过程放大
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param num_it: 迭代次数
    :return: weak_class_arr  弱分类器的集合
            agg_class_est   预测的分类结果值
    """
    weak_class_arr = []
    m = np.shape(data_arr)[0]
    # 初始化 D，设置每个特征的权重值，平均分为m份
    D = np.mat(np.ones((m, 1)) / m)
    agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    for i in range(num_it):
        # 得到决策树的模型
        best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
        print('D: {}'.format(D.T))
        # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
        # 计算每个分类器的 alpha 权重值
        alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
        best_stump['alpha'] = alpha
        # store Stump Params in Array
        weak_class_arr.append(best_stump)
        # print('class_est: {}'.format(class_est.T))
        # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
        # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
        expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
        # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
        # print('(-1取反)预测值 expon=', expon.T)
        # 计算e的expon次方，然后计算得到一个综合的概率的值
        # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
        # multiply是对应项相乘
        D = np.multiply(D, np.exp(expon))
        D = D / D.sum()
        # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
        # print('叠加前的分类结果class_est: {}'.format(class_est.T))
        agg_class_est += alpha * class_est
        print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
        # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
        # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
        agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
                                 np.ones((m, 1)))
        error_rate = agg_errors.sum() / m
        print('total error: {}\n'.format(error_rate))
        if error_rate == 0.0:
            break
    print(D)
    return weak_class_arr

  • 测试代码

    def ada_classify(data_to_class, classifier_arr):
    """
    通过刚刚上面那个函数得到的弱分类器的集合进行预测
    :param data_to_class: 数据集
    :param classifier_arr: 分类器列表
    :return: 正负一，也就是表示分类的结果
    """
    data_mat = np.mat(data_to_class)# 测试9

    m = np.shape(data_mat)[0]
    agg_class_est = np.mat(np.zeros((m, 1)))
    for i in range(len(classifier_arr)):
        class_est = stump_classify(
            data_mat, classifier_arr[i]['dim'],
            classifier_arr[i]['thresh'],
            classifier_arr[i]['ineq']
        )
        agg_class_est += classifier_arr[i]['alpha'] * class_est
        print(agg_class_est)
    return np.sign(agg_class_est)

  • 完整代码：

    # 自适应算法实现实例一
import numpy as np


def load_sim_data():
    """
    测试数据，
    :return: data_arr   feature对应的数据集
            label_arr  feature对应的分类标签
    """
    data_mat = np.matrix([[1.0, 2.1],
                          [2.0, 1.1],
                          [1.3, 1.0],
                          [1.0, 1.0],
                          [2.0, 1.0]])
    class_labels = [1.0, 1.0, -1.0, -1.0, 1.0]
    return data_mat, class_labels
datMat,classLables = load_sim_data()
def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    """
    (将数据集，按照feature列的value进行 二分法切分比较来赋值分类)
    :param data_mat: Matrix数据集
    :param dimen: 特征的哪一个列
    :param thresh_val: 特征列要比较的值
    :param thresh_ineq:
    :return: np.array
    """
    ret_array = np.ones((np.shape(data_mat)[0], 1))
    # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    if thresh_ineq == 'lt':# 假设左边比较一下
        ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    else:# 假设右边比较一下
        ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    return ret_array
# 这个算法是为了寻找最好的单层决策树
def build_stump(data_arr, class_labels, D):
    """
    得到决策树的模型 (这个比较重要，需要看懂）
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param D: 最初的特征权重值
    :return: best_Stump    最优的分类器模型
            min_error     错误率
            best_class_est  训练后的结果集
    """
    data_mat = np.mat(data_arr)
    label_mat = np.mat(class_labels).T

    m, n = np.shape(data_mat)
    num_steps = 10.0
    best_stump = {}
    best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    # 无穷大
    min_err = np.inf
    for i in range(n):
        range_min = data_mat[:, i].min()
        range_max = data_mat[:, i].max()
        step_size = (range_max - range_min) / num_steps
        for j in range(-1, int(num_steps) + 1):
            for inequal in ['lt', 'gt']:
                thresh_val = (range_min + float(j) * step_size)
                predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
                err_arr = np.mat(np.ones((m, 1)))
                err_arr[predicted_vals == label_mat] = 0
                # 这里是矩阵乘法
                weighted_err = D.T * err_arr
                '''
                dim            表示 feature列
                thresh_val      表示树的分界值
                inequal        表示计算树左右颠倒的错误率的情况
                weighted_error  表示整体结果的错误率
                best_class_est    预测的最优结果 （与class_labels对应）
                '''
                # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
                #     i, thresh_val, inequal, weighted_err
                # ))
                if weighted_err < min_err:
                    min_err = weighted_err
                    best_class_est = predicted_vals.copy()#可以保存的结果集储存
                    best_stump['dim'] = i# 第i列
                    best_stump['thresh'] = thresh_val# 阈值
                    best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    # print(best_stump)
    return best_stump, min_err, best_class_est
# print(np.mat(np.ones((5,1))/5))#赋值相同的权重
# [[0.2]
#  [0.2]
#  [0.2]
#  [0.2]
#  [0.2]]
# print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    """
    adaBoost训练过程放大
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param num_it: 迭代次数
    :return: weak_class_arr  弱分类器的集合
            agg_class_est   预测的分类结果值
    """
    weak_class_arr = []
    m = np.shape(data_arr)[0]
    # 初始化 D，设置每个特征的权重值，平均分为m份
    D = np.mat(np.ones((m, 1)) / m)
    agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    for i in range(num_it):
        # 得到决策树的模型
        best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
        print('D: {}'.format(D.T))
        # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
        # 计算每个分类器的 alpha 权重值
        alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
        best_stump['alpha'] = alpha
        # store Stump Params in Array
        weak_class_arr.append(best_stump)
        # print('class_est: {}'.format(class_est.T))
        # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
        # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
        expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
        # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
        # print('(-1取反)预测值 expon=', expon.T)
        # 计算e的expon次方，然后计算得到一个综合的概率的值
        # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
        # multiply是对应项相乘
        D = np.multiply(D, np.exp(expon))
        D = D / D.sum()
        # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
        # print('叠加前的分类结果class_est: {}'.format(class_est.T))
        agg_class_est += alpha * class_est
        print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
        # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
        # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
        agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
                                 np.ones((m, 1)))
        error_rate = agg_errors.sum() / m
        print('total error: {}\n'.format(error_rate))
        if error_rate == 0.0:
            break
    print(D)
    return weak_class_arr
# print(ada_boost_train_ds(datMat,classLables,9))
classLables_arr = ada_boost_train_ds(datMat,classLables,9)

def ada_classify(data_to_class, classifier_arr):
    """
    通过刚刚上面那个函数得到的弱分类器的集合进行预测
    :param data_to_class: 数据集
    :param classifier_arr: 分类器列表
    :return: 正负一，也就是表示分类的结果
    """
    data_mat = np.mat(data_to_class)# 测试9

    m = np.shape(data_mat)[0]
    agg_class_est = np.mat(np.zeros((m, 1)))
    for i in range(len(classifier_arr)):
        class_est = stump_classify(
            data_mat, classifier_arr[i]['dim'],
            classifier_arr[i]['thresh'],
            classifier_arr[i]['ineq']
        )
        agg_class_est += classifier_arr[i]['alpha'] * class_est
        print(agg_class_est)
    return np.sign(agg_class_est)
# print(ada_classify([0,0],classLables_arr))

疝病马数据使用自适应算法实现

  • 和上边代码差不多，就是加了一个rank测试

    import numpy as np
def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    """
    (将数据集，按照feature列的value进行 二分法切分比较来赋值分类)
    :param data_mat: Matrix数据集
    :param dimen: 特征的哪一个列
    :param thresh_val: 特征列要比较的值
    :param thresh_ineq:
    :return: np.array
    """
    ret_array = np.ones((np.shape(data_mat)[0], 1))
    # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    if thresh_ineq == 'lt':# 假设左边比较一下
        ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    else:# 假设右边比较一下
        ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    return ret_array
# 这个算法是为了寻找最好的单层决策树
def build_stump(data_arr, class_labels, D):
    """
    得到决策树的模型 (这个比较重要，需要看懂）
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param D: 最初的特征权重值
    :return: best_Stump    最优的分类器模型
            min_error     错误率
            best_class_est  训练后的结果集
    """
    data_mat = np.mat(data_arr)
    label_mat = np.mat(class_labels).T

    m, n = np.shape(data_mat)
    num_steps = 10.0
    best_stump = {}
    best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    # 无穷大
    min_err = np.inf
    for i in range(n):
        range_min = data_mat[:, i].min()
        range_max = data_mat[:, i].max()
        step_size = (range_max - range_min) / num_steps
        for j in range(-1, int(num_steps) + 1):
            for inequal in ['lt', 'gt']:
                thresh_val = (range_min + float(j) * step_size)
                predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
                err_arr = np.mat(np.ones((m, 1)))
                err_arr[predicted_vals == label_mat] = 0
                # 这里是矩阵乘法
                weighted_err = D.T * err_arr
                '''
                dim            表示 feature列
                thresh_val      表示树的分界值
                inequal        表示计算树左右颠倒的错误率的情况
                weighted_error  表示整体结果的错误率
                best_class_est    预测的最优结果 （与class_labels对应）
                '''
                # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
                #     i, thresh_val, inequal, weighted_err
                # ))
                if weighted_err < min_err:
                    min_err = weighted_err
                    best_class_est = predicted_vals.copy()#可以保存的结果集储存
                    best_stump['dim'] = i# 第i列
                    best_stump['thresh'] = thresh_val# 阈值
                    best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    # print(best_stump)
    return best_stump, min_err, best_class_est
# print(np.mat(np.ones((5,1))/5))#赋值相同的权重
# [[0.2]
#  [0.2]
#  [0.2]
#  [0.2]
#  [0.2]]
# print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    """
    adaBoost训练过程放大
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param num_it: 迭代次数
    :return: weak_class_arr  弱分类器的集合
            agg_class_est   预测的分类结果值
    """
    weak_class_arr = []
    m = np.shape(data_arr)[0]
    # 初始化 D，设置每个特征的权重值，平均分为m份
    D = np.mat(np.ones((m, 1)) / m)
    agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    for i in range(num_it):
        # 得到决策树的模型
        best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
        # print('D: {}'.format(D.T))
        # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
        # 计算每个分类器的 alpha 权重值
        alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
        best_stump['alpha'] = alpha
        # store Stump Params in Array
        weak_class_arr.append(best_stump)
        # print('class_est: {}'.format(class_est.T))
        # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
        # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
        expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
        # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
        # print('(-1取反)预测值 expon=', expon.T)
        # 计算e的expon次方，然后计算得到一个综合的概率的值
        # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
        # multiply是对应项相乘
        D = np.multiply(D, np.exp(expon))
        D = D / D.sum()
        # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
        # print('叠加前的分类结果class_est: {}'.format(class_est.T))
        agg_class_est += alpha * class_est
        # print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
        # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
        # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
        agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
                                 np.ones((m, 1)))
        error_rate = agg_errors.sum() / m
        print('total error: {}\n'.format(error_rate))
        if error_rate == 0.0:
            break
    # print(D)
    return weak_class_arr
def loadDataSet(fileName):
    numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    dataMat = [];labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = []
        curLine = line.strip().split('\t')
        # 将21个特征保存起来
        for i in range(numFeat-1):
            lineArr.append((float(curLine[i])))
        # print(len(lineArr))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat
datArr,labelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTraining2.txt')
# print(ada_boost_train_ds(datArr,labelArr,10))
classifiterArray = ada_boost_train_ds(datArr,labelArr,10000)
def ada_classify(data_to_class, classifier_arr):
    """
    通过刚刚上面那个函数得到的弱分类器的集合进行预测
    :param data_to_class: 数据集
    :param classifier_arr: 分类器列表
    :return: 正负一，也就是表示分类的结果
    """
    data_mat = np.mat(data_to_class)# 测试9

    m = np.shape(data_mat)[0]
    agg_class_est = np.mat(np.zeros((m, 1)))
    for i in range(len(classifier_arr)):
        class_est = stump_classify(
            data_mat, classifier_arr[i]['dim'],
            classifier_arr[i]['thresh'],
            classifier_arr[i]['ineq']
        )
        agg_class_est += classifier_arr[i]['alpha'] * class_est
        # print(agg_class_est)
    return np.sign(agg_class_est)
def test():
    testArr,testLabelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTest2.txt')
    pridict = ada_classify(testArr,classifiterArray)
    errArr = np.mat(np.ones((67,1)))
    error = errArr[pridict!=np.mat(testLabelArr).T].sum()
    print('error = {}'.format(error/len(testLabelArr)))
test()

  • 和书上结果差不多：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z5bLqxDu-1578039599589)(/home/ach/.config/Typora/typora-user-images/image-20200103161235836.png)]

处理非均衡问题

  • 代码

    import numpy as np
def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    """
    (将数据集，按照feature列的value进行 二分法切分比较来赋值分类)
    :param data_mat: Matrix数据集
    :param dimen: 特征的哪一个列
    :param thresh_val: 特征列要比较的值
    :param thresh_ineq:
    :return: np.array
    """
    ret_array = np.ones((np.shape(data_mat)[0], 1))
    # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    if thresh_ineq == 'lt':# 假设左边比较一下
        ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    else:# 假设右边比较一下
        ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    return ret_array
# 这个算法是为了寻找最好的单层决策树
def build_stump(data_arr, class_labels, D):
    """
    得到决策树的模型 (这个比较重要，需要看懂）
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param D: 最初的特征权重值
    :return: best_Stump    最优的分类器模型
            min_error     错误率
            best_class_est  训练后的结果集
    """
    data_mat = np.mat(data_arr)
    label_mat = np.mat(class_labels).T

    m, n = np.shape(data_mat)
    num_steps = 10.0
    best_stump = {}
    best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    # 无穷大
    min_err = np.inf
    for i in range(n):
        range_min = data_mat[:, i].min()
        range_max = data_mat[:, i].max()
        step_size = (range_max - range_min) / num_steps
        for j in range(-1, int(num_steps) + 1):
            for inequal in ['lt', 'gt']:
                thresh_val = (range_min + float(j) * step_size)
                predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
                err_arr = np.mat(np.ones((m, 1)))
                err_arr[predicted_vals == label_mat] = 0
                # 这里是矩阵乘法
                weighted_err = D.T * err_arr
                '''
                dim            表示 feature列
                thresh_val      表示树的分界值
                inequal        表示计算树左右颠倒的错误率的情况
                weighted_error  表示整体结果的错误率
                best_class_est    预测的最优结果 （与class_labels对应）
                '''
                # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
                #     i, thresh_val, inequal, weighted_err
                # ))
                if weighted_err < min_err:
                    min_err = weighted_err
                    best_class_est = predicted_vals.copy()#可以保存的结果集储存
                    best_stump['dim'] = i# 第i列
                    best_stump['thresh'] = thresh_val# 阈值
                    best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    # print(best_stump)
    return best_stump, min_err, best_class_est
# print(np.mat(np.ones((5,1))/5))#赋值相同的权重
# [[0.2]
#  [0.2]
#  [0.2]
#  [0.2]
#  [0.2]]
# print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    """
    adaBoost训练过程放大
    :param data_arr: 特征标签集合
    :param class_labels: 分类标签集合
    :param num_it: 迭代次数
    :return: weak_class_arr  弱分类器的集合
            agg_class_est   预测的分类结果值
    """
    weak_class_arr = []
    m = np.shape(data_arr)[0]
    # 初始化 D，设置每个特征的权重值，平均分为m份
    D = np.mat(np.ones((m, 1)) / m)
    agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    for i in range(num_it):
        # 得到决策树的模型
        best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
        # print('D: {}'.format(D.T))
        # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
        # 计算每个分类器的 alpha 权重值
        alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
        best_stump['alpha'] = alpha
        # store Stump Params in Array
        weak_class_arr.append(best_stump)
        # print('class_est: {}'.format(class_est.T))
        # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
        # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
        expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
        # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
        # print('(-1取反)预测值 expon=', expon.T)
        # 计算e的expon次方，然后计算得到一个综合的概率的值
        # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
        # multiply是对应项相乘
        D = np.multiply(D, np.exp(expon))
        D = D / D.sum()
        # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
        # print('叠加前的分类结果class_est: {}'.format(class_est.T))
        agg_class_est += alpha * class_est
        # print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
        # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
        # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
        agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
                                 np.ones((m, 1)))
        error_rate = agg_errors.sum() / m
        print('total error: {}\n'.format(error_rate))
        if error_rate == 0.0:
            break
    # print(D)
    return weak_class_arr,agg_class_est
def loadDataSet(fileName):
    numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    dataMat = [];labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = []
        curLine = line.strip().split('\t')
        # 将21个特征保存起来
        for i in range(numFeat-1):
            lineArr.append((float(curLine[i])))
        # print(len(lineArr))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat
datArr,labelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTraining2.txt')
# print(ada_boost_train_ds(datArr,labelArr,10))
classifiterArray,aggClassEst = ada_boost_train_ds(datArr,labelArr,100)
def plot_roc(pred_strengths, class_labels):
    """
    (打印ROC曲线，并计算AUC的面积大小)
    :param pred_strengths: 最终预测结果的权重值
    :param class_labels: 原始数据的分类结果集
    :return:
    """
    import matplotlib.pyplot as plt
    # variable to calculate AUC
    y_sum = 0.0
    # 对正样本的进行求和
    num_pos_class = np.sum(np.array(class_labels) == 1.0)
    # 正样本的概率
    y_step = 1 / float(num_pos_class)
    # 负样本的概率
    x_step = 1 / float(len(class_labels) - num_pos_class)
    # np.argsort函数返回的是数组值从小到大的索引值
    # get sorted index, it's reverse
    sorted_indicies = pred_strengths.argsort()
    # 测试结果是否是从小到大排列
    # 可以选择打印看一下
    # 开始创建模版对象
    fig = plt.figure()
    fig.clf()
    ax = plt.subplot(111)
    # cursor光标值
    cur = (1.0, 1.0)
    # loop through all the values, drawing a line segment at each point
    for index in sorted_indicies.tolist()[0]:
        if class_labels[index] == 1.0:
            del_x = 0
            del_y = y_step
        else:
            del_x = x_step
            del_y = 0
            y_sum += cur[1]
        # draw line from cur to (cur[0]-delX, cur[1]-delY)
        # 画点连线 (x1, x2, y1, y2)
        # print cur[0], cur[0]-delX, cur[1], cur[1]-delY
        ax.plot([cur[0], cur[0] - del_x], [cur[1], cur[1] - del_y], c='b')
        cur = (cur[0] - del_x, cur[1] - del_y)
    # 画对角的虚线线
    ax.plot([0, 1], [0, 1], 'b--')
    plt.xlabel('False positive rate')
    plt.ylabel('True positive rate')
    plt.title('ROC curve for AdaBoost horse colic detection system')
    # 设置画图的范围区间 (x1, x2, y1, y2)
    ax.axis([0, 1, 0, 1])
    plt.show()
    '''
    参考说明：http://blog.csdn.net/wenyusuran/article/details/39056013
    为了计算 AUC ，我们需要对多个小矩形的面积进行累加。
    这些小矩形的宽度是x_step，因此可以先对所有矩形的高度进行累加，最后再乘以x_step得到其总面积。
    所有高度的和(y_sum)随着x轴的每次移动而渐次增加。
    '''
    print("the Area Under the Curve is: ", y_sum * x_step)
plot_roc(aggClassEst.T,labelArr)

  • 运行结果：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BloCDxcE-1578039599589)(/home/ach/.config/Typora/typora-user-images/image-20200103161919589.png)]

    Skleanring实现adaboost算法

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import  DecisionTreeClassifier
import numpy as np
def loadDataSet(fileName):
    numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    dataMat = [];labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = []
        curLine = line.strip().split('\t')
        # 将21个特征保存起来
        for i in range(numFeat-1):
            lineArr.append((float(curLine[i])))
        # print(len(lineArr))
        dataMat.append(lineArr)
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat
datArr,labelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTraining2.txt')
clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2,min_samples_split=5,min_samples_leaf=5),n_estimators=40,random_state=10000)
clf.fit(np.mat(datArr),labelArr)
datArr1,labelArr1 = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTest2.txt')
print(clf.score(np.mat(datArr1),labelArr1))
胖虎艾春辉
关注
专栏目录
Boosting之Adaboost简单实现
此心安处是吾乡
04-26 360
《机器学习实战》第七章，Adaboost的实现。有两个问题： 1. 基分类器是用的是单决策树桩，选择最好的分类器是遍历所有可能，挑选加权误差最小的那个单决策树桩。实际应用应该选择普通CART树做基分类器，那么权重对基分类器的影响总不能遍历所有可能存在的决策树情况。这里的逻辑需要再确认 2. 如果基分类器的加权误差大于0.5，这里比较方式有大于和小于，所以不存在小于0.5的情况，如果存在小于0.5
机器学习实战之AdaBoost练习---python
瑶子的博客
09-13 581
# -*-coding:utf-8 -*- import numpy as np import matplotlib.pyplot as plt ''' 创建单层决策树的数据集 return: dataMat---数据矩阵 classLabels---数据标签 ''' def loadSimpData(): dataMat = (...
AdaBoost算法详解
最新发布
bb8886的博客
03-17 2649
Adaboost算法是一种常用的集成学习算法，解决的是二分类问题，它可以将多个弱分类器（比如决策树）组合成一个强分类器。其基本思想是通过对数据集进行加权和重复训练来提高分类器的准确性。
Adaboost算法原理与实例
blinkyou001的博客
01-13 2868
本文详细讲解了adboost算法的基本原理，并通过实例讲解了算法过程。
AdaBoost 算法
Rnan_prince的博客
02-06 4295
AdaBoost 算法 是一种经典的集成学习算法，它将多个弱分类器集成起来，以达到较高的分类准确率，广泛应用于数据分类、人脸检测等应用中。尤其在人脸检测方面，AdaBoost 是非常经典、成功的一个算法。弱分类器被线性组合成为一个强分类器。 一、面临两个问题： 在每一轮，如何改变训练数据的概率分布或者权值分布。 如何将弱分类器组合成强分类器。 二、AdaBoost 的思路： ...
AdaBoost算法实例详解
热门推荐
胖胖大海的博客
05-23 2万+
AdaBoost算法其实很精炼，算法流程也好理解，但是看了算法的解释版本之后，什么前向分布算法，什么指数损失函数之后有点迷糊了。抛开这些理论性的推导不谈（其实是因为能力有限），通过例子直观的了解AdaBoost算法的计算过程。 简要叙述一下AdaBoost算法的主要过程： AdaBoost为每个数据样本分配权重，权重符合概率分布，初始权重符合均匀分布，串行训练M个模型，依据每轮训练的模型的错误率（被误分类样本的权重之和）确定当前模型在最终模型中的权重，以及更新训练样本的权重，误分类样本权重升高，分类正确
AdaBoost算法
ab0902cd的博客
07-02 2092
AdaBoost算法简介 AdaBoost算法的全称是自适应Boosting（Adaptive Boosting），是一种二分类器，它用弱分类器的线性组合构造强分类器。弱分类器的性能不用太好，只需要比随机猜测强，依靠它们可以构造出一个非常准确的强分类器。强分类器的计算公式为： 其中x是输入向量，F(x)是强分类器，是弱分类器，是弱分类器的权重值，是一个正数，T为弱分类器的数量。弱分类器的输出值为+1或-1，分别对应于正样本和负样本。分类时的判定规则为： 其中sgn是符号函数。强分类器的输出值.
Adaboost算法详细讲解
jakkiejinn的博客
12-05 6228
Adaboost(Adaptive Boosting):Adaboost是Boosting模型，和bagging模型（随机森林）不同的是：Adaboost会构建多个若分类器(决策树的max_depth=1)，每个分类器根据自身的准确性来确定各自的权重，再合体。同时Adaboost会根据前一次的分类效果调整数据权重。具体说来，整个Adaboost 迭代算法分为3步：1. 初始化训练数据的权值分布。如果有N个样本，则每一个训练样本最开始时都被赋予相同的权值：1/N。2. 训练弱分类器（带有样本权重的分类器都可以
【AdaBoost算法】集成学习——AdaBoost算法实例说明
NZR的blog
04-21 4072
【AdaBoost算法】集成学习——AdaBoost算法实例说明 AdaBoost算法是数据挖掘十大算法之一，但是部分参考书上只给了该算法的数学推导过程，具体的流程并未详细举例加以解释，因此不利于学习者的掌握和领悟，通过查找相关资料，发现知乎有篇博文介绍的很是详细，并且附有具体实例加以理解。 （十三）通俗易懂理解——Adaboost算法原理 一、AdaBoost算法过程 给定训练数据集：（x1,y1）,(x2,y2)···(xn,yn)，其中yi属于{1，-1}用于表示训练样本的类别标签，i=1,…,N。A
基于Matlab使用BP-Adaboost算法弱分离器预测（源码+数据）.rar
06-28
1、资源内容：基于Matlab使用BP_Adaboost算法弱分离器预测（源码+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、解压说明：本资源...
基于BP_Adaboost算法的公司财务预警建模代码.zip
03-22
在本项目中，我们关注的是使用BP（Backpropagation）神经网络与Adaboost算法结合进行公司财务预警的建模工作。这是一种常见的数据挖掘技术，用于预测企业的财务风险，及时发现潜在的财务危机。Matlab作为强大的数值...
国信证券_20160531_国信证券机器学习专题研究：Adaboost算法下的多因子选股.pdf
05-12
### 国信证券机器学习专题研究：Adaboost算法下的多因子选股 #### Adaboost算法概述 Adaboost（Adaptive Boosting）算法是一种迭代式的机器学习算法，主要用于分类问题，尤其适用于处理非线性可分的数据集。该算法...
Adaboost算法.docx
03-03
"Adaboost算法" Adaboost算法是一种迭代算法，核心思想是针对同一个训练集训练不同的分类器（弱分类器），然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。其算法本身是通过改变数据分布来实现...
基于AdaBoost算法的情感分析研究1
08-08
《基于AdaBoost算法的情感分析研究》 随着信息技术的飞速发展，社交媒体已成为人们日常生活中不可或缺的一部分，特别是微博，它的普及度极高，用户基数庞大，涵盖了各种话题，对人们的生活产生了深远影响。在这种...
二手车预测：task2：数据分布
weixin_42479155的博客
03-22 1万+
2.1 EDA目标 EDA的价值主要在于熟悉数据集，了解数据集，对数据集进行验证来确定所获得数据集可以用于接下来的机器学习或者深度学习使用。 当了解了数据集之后我们下一步就是要去了解变量间的相互关系以及变量与预测值之间的存在关系。 引导数据科学从业者进行数据处理以及特征工程的步骤,使数据集的结构和特征集让接下来的预测问题更加可靠。 完成对于数据的探索性分析，并对于数据进行一些图表或...
pytorch-文本情感分类
weixin_42479155的博客
02-25 6053
文本情感分类 文本分类是自然语言处理的一个常见任务，它把一段不定长的文本序列变换为文本的类别。本节关注它的一个子问题：使用文本情感分类来分析文本作者的情绪。这个问题也叫情感分析，并有着广泛的应用。 同搜索近义词和类比词一样，文本分类也属于词嵌入的下游应用。在本节中，我们将应用预训练的词向量和含多个隐藏层的双向循环神经网络与卷积神经网络，来判断一段不定长的文本序列中包含的是正面还是负面的情绪。后续内...
使用stratifiedKFold进行分层交叉验证时候报错:ValueError: Supported target types are: ('binary', 'multiclass'). Got
weixin_42479155的博客
03-22 5503
ValueError Traceback (most recent call last) <ipython-input-42-2ab744268d80> in <module>() 20 print('---------分割线--------------') 21 sfolder = Stra...
pytorch-过拟合、欠拟合及其解决方案
weixin_42479155的博客
02-16 3092
过拟合、欠拟合及其解决方案 过拟合、欠拟合的概念 权重衰减 丢弃法 模型选择、过拟合和欠拟合 训练误差和泛化误差 在解释上述现象之前，我们需要区分训练误差（training error）和泛化误差（generalization error）。通俗来讲，前者指模型在训练数据集上表现出的误差，后者指模型在任意一个测试数据样本上表现出的误差的期望，并常常通过测试数据集上的误差来近似。计算训练误差和泛...
Adaboost 算法
09-13
Adaboost算法是一种集成学习方法，它通过将多个弱分类器组合成一个强分类器来提高分类的性能。该算法的主要原理是通过迭代的方式，每次都对分类错误的样本进行加权，以便使下一次迭代的分类器能够更好地对这些错误分类样本进行处理。 Adaboost算法的具体实现可以通过Sklearn库中的AdaBoostClassifier来实现。在该实现中，基本分类器默认为决策树，用户可以通过设置n_estimators参数来控制迭代的次数，learning_rate参数来控制学习率。此外，还可以通过设置random_state参数来指定随机种子。 Adaboost算法主要解决了boosting面临的两个问题。首先，它通过提高被前一轮分类器错误分类的样本的权重，降低那些分类正确样本的权重，使分类器更加关注分类错误的样本。其次，Adaboost还通过加大分类错误率低的分类器的权重，减小分类错误率高的分类器的权重，使得分类器集合更加关注分类性能较好的分类器。 具体的公式推导过程可以参考引用[3]中的内容。Adaboost算法通过迭代更新样本的权重，并使用加权投票的方式组合多个弱分类器，从而得到最终的强分类器。 总的来说，Adaboost算法是一种强大的分类算法，通过迭代的方式不断提高分类器的性能。它能够有效地处理分类错误的样本，并且能够将多个弱分类器组合成一个强分类器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值