Adaboost算法

港控/mmm° 2023-06-27 05:35 93阅读 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

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

    缺点：对离群点敏感。

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

案例一：自适应算法实现

  • 导入数据：

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

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

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

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

    1. # 这个算法是为了寻找最好的单层决策树
    2. def build_stump(data_arr, class_labels, D):
    3.     """ 得到决策树的模型 (这个比较重要，需要看懂） :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param D: 最初的特征权重值 :return: best_Stump 最优的分类器模型 min_error 错误率 best_class_est 训练后的结果集 """
    4.     data_mat = np.mat(data_arr)
    5.     label_mat = np.mat(class_labels).T
    7.     m, n = np.shape(data_mat)
    8.     num_steps = 10.0
    9.     best_stump = { }
    10.     best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    11.     # 无穷大
    12.     min_err = np.inf
    13.     for i in range(n):
    14.         range_min = data_mat[:, i].min()
    15.         range_max = data_mat[:, i].max()
    16.         step_size = (range_max - range_min) / num_steps
    17.         for j in range(-1, int(num_steps) + 1):
    18.             for inequal in ['lt', 'gt']:
    19.                 thresh_val = (range_min + float(j) * step_size)
    20.                 predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
    21.                 err_arr = np.mat(np.ones((m, 1)))
    22.                 err_arr[predicted_vals == label_mat] = 0
    23.                 # 这里是矩阵乘法
    24.                 weighted_err = D.T * err_arr
    25.                 ''' dim 表示 feature列 thresh_val 表示树的分界值 inequal 表示计算树左右颠倒的错误率的情况 weighted_error 表示整体结果的错误率 best_class_est 预测的最优结果 （与class_labels对应） '''
    26.                 # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
    27.                 # i, thresh_val, inequal, weighted_err
    28.                 # ))
    29.                 if weighted_err < min_err:
    30.                     min_err = weighted_err
    31.                     best_class_est = predicted_vals.copy()#可以保存的结果集储存
    32.                     best_stump['dim'] = i# 第i列
    33.                     best_stump['thresh'] = thresh_val# 阈值
    34.                     best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    35.     # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    36.     # print(best_stump)
    37.     return best_stump, min_err, best_class_est
    38. # print(np.mat(np.ones((5,1))/5))#赋值相同的权重
    39. # [[0.2]
    40. # [0.2]
    41. # [0.2]
    42. # [0.2]
    43. # [0.2]]
    44. # print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))

  • 构建自适应算法

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

  • 测试代码

    1. def ada_classify(data_to_class, classifier_arr):
    2.     """ 通过刚刚上面那个函数得到的弱分类器的集合进行预测 :param data_to_class: 数据集 :param classifier_arr: 分类器列表 :return: 正负一，也就是表示分类的结果 """
    3.     data_mat = np.mat(data_to_class)# 测试9
    5.     m = np.shape(data_mat)[0]
    6.     agg_class_est = np.mat(np.zeros((m, 1)))
    7.     for i in range(len(classifier_arr)):
    8.         class_est = stump_classify(
    9.             data_mat, classifier_arr[i]['dim'],
    10.             classifier_arr[i]['thresh'],
    11.             classifier_arr[i]['ineq']
    12.         )
    13.         agg_class_est += classifier_arr[i]['alpha'] * class_est
    14.         print(agg_class_est)
    15.     return np.sign(agg_class_est)

  • 完整代码：

    1. # 自适应算法实现实例一
    2. import numpy as np
  1.     def load_sim_data():
  2.         """ 测试数据， :return: data_arr feature对应的数据集 label_arr feature对应的分类标签 """
  3.         data_mat = np.matrix([[1.0, 2.1],
  4.                               [2.0, 1.1],
  5.                               [1.3, 1.0],
  6.                               [1.0, 1.0],
  7.                               [2.0, 1.0]])
  8.         class_labels = [1.0, 1.0, -1.0, -1.0, 1.0]
  9.         return data_mat, class_labels
  10.     datMat,classLables = load_sim_data()
  11.     def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
  12.         """ (将数据集，按照feature列的value进行 二分法切分比较来赋值分类) :param data_mat: Matrix数据集 :param dimen: 特征的哪一个列 :param thresh_val: 特征列要比较的值 :param thresh_ineq: :return: np.array """
  13.         ret_array = np.ones((np.shape(data_mat)[0], 1))
  14.         # data_mat[:, dimen] 表示数据集中第dimen列的所有值
  15.         # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
  16.         # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
  17.         if thresh_ineq == 'lt':# 假设左边比较一下
  18.             ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
  19.         else:# 假设右边比较一下
  20.             ret_array[data_mat[:, dimen] > thresh_val] = -1.0
  21.         return ret_array
  22.     # 这个算法是为了寻找最好的单层决策树
  23.     def build_stump(data_arr, class_labels, D):
  24.         """ 得到决策树的模型 (这个比较重要，需要看懂） :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param D: 最初的特征权重值 :return: best_Stump 最优的分类器模型 min_error 错误率 best_class_est 训练后的结果集 """
  25.         data_mat = np.mat(data_arr)
  26.         label_mat = np.mat(class_labels).T
  28.         m, n = np.shape(data_mat)
  29.         num_steps = 10.0
  30.         best_stump = { }
  31.         best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
  32.         # 无穷大
  33.         min_err = np.inf
  34.         for i in range(n):
  35.             range_min = data_mat[:, i].min()
  36.             range_max = data_mat[:, i].max()
  37.             step_size = (range_max - range_min) / num_steps
  38.             for j in range(-1, int(num_steps) + 1):
  39.                 for inequal in ['lt', 'gt']:
  40.                     thresh_val = (range_min + float(j) * step_size)
  41.                     predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
  42.                     err_arr = np.mat(np.ones((m, 1)))
  43.                     err_arr[predicted_vals == label_mat] = 0
  44.                     # 这里是矩阵乘法
  45.                     weighted_err = D.T * err_arr
  46.                     ''' dim 表示 feature列 thresh_val 表示树的分界值 inequal 表示计算树左右颠倒的错误率的情况 weighted_error 表示整体结果的错误率 best_class_est 预测的最优结果 （与class_labels对应） '''
  47.                     # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
  48.                     # i, thresh_val, inequal, weighted_err
  49.                     # ))
  50.                     if weighted_err < min_err:
  51.                         min_err = weighted_err
  52.                         best_class_est = predicted_vals.copy()#可以保存的结果集储存
  53.                         best_stump['dim'] = i# 第i列
  54.                         best_stump['thresh'] = thresh_val# 阈值
  55.                         best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
  56.         # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
  57.         # print(best_stump)
  58.         return best_stump, min_err, best_class_est
  59.     # print(np.mat(np.ones((5,1))/5))#赋值相同的权重
  60.     # [[0.2]
  61.     # [0.2]
  62.     # [0.2]
  63.     # [0.2]
  64.     # [0.2]]
  65.     # print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
  66.     def ada_boost_train_ds(data_arr, class_labels, num_it=40):
  67.         """ adaBoost训练过程放大 :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param num_it: 迭代次数 :return: weak_class_arr 弱分类器的集合 agg_class_est 预测的分类结果值 """
  68.         weak_class_arr = []
  69.         m = np.shape(data_arr)[0]
  70.         # 初始化 D，设置每个特征的权重值，平均分为m份
  71.         D = np.mat(np.ones((m, 1)) / m)
  72.         agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
  73.         for i in range(num_it):
  74.             # 得到决策树的模型
  75.             best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
  76.             print('D: {}'.format(D.T))
  77.             # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
  78.             # 计算每个分类器的 alpha 权重值
  79.             alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
  80.             best_stump['alpha'] = alpha
  81.             # store Stump Params in Array
  82.             weak_class_arr.append(best_stump)
  83.             # print('class_est: {}'.format(class_est.T))
  84.             # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
  85.             # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
  86.             expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
  87.             # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
  88.             # print('(-1取反)预测值 expon=', expon.T)
  89.             # 计算e的expon次方，然后计算得到一个综合的概率的值
  90.             # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
  91.             # multiply是对应项相乘
  92.             D = np.multiply(D, np.exp(expon))
  93.             D = D / D.sum()
  94.             # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
  95.             # print('叠加前的分类结果class_est: {}'.format(class_est.T))
  96.             agg_class_est += alpha * class_est
  97.             print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
  98.             # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
  99.             # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
  100.             agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
  101.                                      np.ones((m, 1)))
  102.             error_rate = agg_errors.sum() / m
  103.             print('total error: {}\n'.format(error_rate))
  104.             if error_rate == 0.0:
  105.                 break
  106.         print(D)
  107.         return weak_class_arr
  108.     # print(ada_boost_train_ds(datMat,classLables,9))
  109.     classLables_arr = ada_boost_train_ds(datMat,classLables,9)
  111.     def ada_classify(data_to_class, classifier_arr):
  112.         """ 通过刚刚上面那个函数得到的弱分类器的集合进行预测 :param data_to_class: 数据集 :param classifier_arr: 分类器列表 :return: 正负一，也就是表示分类的结果 """
  113.         data_mat = np.mat(data_to_class)# 测试9
  115.         m = np.shape(data_mat)[0]
  116.         agg_class_est = np.mat(np.zeros((m, 1)))
  117.         for i in range(len(classifier_arr)):
  118.             class_est = stump_classify(
  119.                 data_mat, classifier_arr[i]['dim'],
  120.                 classifier_arr[i]['thresh'],
  121.                 classifier_arr[i]['ineq']
  122.             )
  123.             agg_class_est += classifier_arr[i]['alpha'] * class_est
  124.             print(agg_class_est)
  125.         return np.sign(agg_class_est)
  126.     # print(ada_classify([0,0],classLables_arr))

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

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

    1. import numpy as np
    2. def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    3.     """ (将数据集，按照feature列的value进行 二分法切分比较来赋值分类) :param data_mat: Matrix数据集 :param dimen: 特征的哪一个列 :param thresh_val: 特征列要比较的值 :param thresh_ineq: :return: np.array """
    4.     ret_array = np.ones((np.shape(data_mat)[0], 1))
    5.     # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    6.     # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    7.     # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    8.     if thresh_ineq == 'lt':# 假设左边比较一下
    9.         ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    10.     else:# 假设右边比较一下
    11.         ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    12.     return ret_array
    13. # 这个算法是为了寻找最好的单层决策树
    14. def build_stump(data_arr, class_labels, D):
    15.     """ 得到决策树的模型 (这个比较重要，需要看懂） :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param D: 最初的特征权重值 :return: best_Stump 最优的分类器模型 min_error 错误率 best_class_est 训练后的结果集 """
    16.     data_mat = np.mat(data_arr)
    17.     label_mat = np.mat(class_labels).T
    19.     m, n = np.shape(data_mat)
    20.     num_steps = 10.0
    21.     best_stump = { }
    22.     best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    23.     # 无穷大
    24.     min_err = np.inf
    25.     for i in range(n):
    26.         range_min = data_mat[:, i].min()
    27.         range_max = data_mat[:, i].max()
    28.         step_size = (range_max - range_min) / num_steps
    29.         for j in range(-1, int(num_steps) + 1):
    30.             for inequal in ['lt', 'gt']:
    31.                 thresh_val = (range_min + float(j) * step_size)
    32.                 predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
    33.                 err_arr = np.mat(np.ones((m, 1)))
    34.                 err_arr[predicted_vals == label_mat] = 0
    35.                 # 这里是矩阵乘法
    36.                 weighted_err = D.T * err_arr
    37.                 ''' dim 表示 feature列 thresh_val 表示树的分界值 inequal 表示计算树左右颠倒的错误率的情况 weighted_error 表示整体结果的错误率 best_class_est 预测的最优结果 （与class_labels对应） '''
    38.                 # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
    39.                 # i, thresh_val, inequal, weighted_err
    40.                 # ))
    41.                 if weighted_err < min_err:
    42.                     min_err = weighted_err
    43.                     best_class_est = predicted_vals.copy()#可以保存的结果集储存
    44.                     best_stump['dim'] = i# 第i列
    45.                     best_stump['thresh'] = thresh_val# 阈值
    46.                     best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    47.     # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    48.     # print(best_stump)
    49.     return best_stump, min_err, best_class_est
    50. # print(np.mat(np.ones((5,1))/5))#赋值相同的权重
    51. # [[0.2]
    52. # [0.2]
    53. # [0.2]
    54. # [0.2]
    55. # [0.2]]
    56. # print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
    57. def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    58.     """ adaBoost训练过程放大 :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param num_it: 迭代次数 :return: weak_class_arr 弱分类器的集合 agg_class_est 预测的分类结果值 """
    59.     weak_class_arr = []
    60.     m = np.shape(data_arr)[0]
    61.     # 初始化 D，设置每个特征的权重值，平均分为m份
    62.     D = np.mat(np.ones((m, 1)) / m)
    63.     agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    64.     for i in range(num_it):
    65.         # 得到决策树的模型
    66.         best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
    67.         # print('D: {}'.format(D.T))
    68.         # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
    69.         # 计算每个分类器的 alpha 权重值
    70.         alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
    71.         best_stump['alpha'] = alpha
    72.         # store Stump Params in Array
    73.         weak_class_arr.append(best_stump)
    74.         # print('class_est: {}'.format(class_est.T))
    75.         # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
    76.         # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
    77.         expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
    78.         # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
    79.         # print('(-1取反)预测值 expon=', expon.T)
    80.         # 计算e的expon次方，然后计算得到一个综合的概率的值
    81.         # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
    82.         # multiply是对应项相乘
    83.         D = np.multiply(D, np.exp(expon))
    84.         D = D / D.sum()
    85.         # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
    86.         # print('叠加前的分类结果class_est: {}'.format(class_est.T))
    87.         agg_class_est += alpha * class_est
    88.         # print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
    89.         # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
    90.         # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
    91.         agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
    92.                                  np.ones((m, 1)))
    93.         error_rate = agg_errors.sum() / m
    94.         print('total error: {}\n'.format(error_rate))
    95.         if error_rate == 0.0:
    96.             break
    97.     # print(D)
    98.     return weak_class_arr
    99. def loadDataSet(fileName):
    100.     numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    101.     dataMat = [];labelMat = []
    102.     fr = open(fileName)
    103.     for line in fr.readlines():
    104.         lineArr = []
    105.         curLine = line.strip().split('\t')
    106.         # 将21个特征保存起来
    107.         for i in range(numFeat-1):
    108.             lineArr.append((float(curLine[i])))
    109.         # print(len(lineArr))
    110.         dataMat.append(lineArr)
    111.         labelMat.append(float(curLine[-1]))
    112.     return dataMat,labelMat
    113. datArr,labelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTraining2.txt')
    114. # print(ada_boost_train_ds(datArr,labelArr,10))
    115. classifiterArray = ada_boost_train_ds(datArr,labelArr,10000)
    116. def ada_classify(data_to_class, classifier_arr):
    117.     """ 通过刚刚上面那个函数得到的弱分类器的集合进行预测 :param data_to_class: 数据集 :param classifier_arr: 分类器列表 :return: 正负一，也就是表示分类的结果 """
    118.     data_mat = np.mat(data_to_class)# 测试9
    120.     m = np.shape(data_mat)[0]
    121.     agg_class_est = np.mat(np.zeros((m, 1)))
    122.     for i in range(len(classifier_arr)):
    123.         class_est = stump_classify(
    124.             data_mat, classifier_arr[i]['dim'],
    125.             classifier_arr[i]['thresh'],
    126.             classifier_arr[i]['ineq']
    127.         )
    128.         agg_class_est += classifier_arr[i]['alpha'] * class_est
    129.         # print(agg_class_est)
    130.     return np.sign(agg_class_est)
    131. def test():
    132.     testArr,testLabelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTest2.txt')
    133.     pridict = ada_classify(testArr,classifiterArray)
    134.     errArr = np.mat(np.ones((67,1)))
    135.     error = errArr[pridict!=np.mat(testLabelArr).T].sum()
    136.     print('error = {}'.format(error/len(testLabelArr)))
    137. test()

  • 和书上结果差不多：

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

处理非均衡问题

  • 代码

    1. import numpy as np
    2. def stump_classify(data_mat, dimen, thresh_val, thresh_ineq):
    3.     """ (将数据集，按照feature列的value进行 二分法切分比较来赋值分类) :param data_mat: Matrix数据集 :param dimen: 特征的哪一个列 :param thresh_val: 特征列要比较的值 :param thresh_ineq: :return: np.array """
    4.     ret_array = np.ones((np.shape(data_mat)[0], 1))
    5.     # data_mat[:, dimen] 表示数据集中第dimen列的所有值
    6.     # thresh_ineq == 'lt'表示修改左边的值，gt表示修改右边的值
    7.     # （这里其实我建议理解为转换左右边，就是一棵树的左右孩子，可能有点问题。。。待考证）
    8.     if thresh_ineq == 'lt':# 假设左边比较一下
    9.         ret_array[data_mat[:, dimen] <= thresh_val] = -1.0
    10.     else:# 假设右边比较一下
    11.         ret_array[data_mat[:, dimen] > thresh_val] = -1.0
    12.     return ret_array
    13. # 这个算法是为了寻找最好的单层决策树
    14. def build_stump(data_arr, class_labels, D):
    15.     """ 得到决策树的模型 (这个比较重要，需要看懂） :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param D: 最初的特征权重值 :return: best_Stump 最优的分类器模型 min_error 错误率 best_class_est 训练后的结果集 """
    16.     data_mat = np.mat(data_arr)
    17.     label_mat = np.mat(class_labels).T
    19.     m, n = np.shape(data_mat)
    20.     num_steps = 10.0
    21.     best_stump = { }
    22.     best_class_est = np.mat(np.zeros((m, 1)))#训练后的结果集
    23.     # 无穷大
    24.     min_err = np.inf
    25.     for i in range(n):
    26.         range_min = data_mat[:, i].min()
    27.         range_max = data_mat[:, i].max()
    28.         step_size = (range_max - range_min) / num_steps
    29.         for j in range(-1, int(num_steps) + 1):
    30.             for inequal in ['lt', 'gt']:
    31.                 thresh_val = (range_min + float(j) * step_size)
    32.                 predicted_vals = stump_classify(data_mat, i, thresh_val, inequal)
    33.                 err_arr = np.mat(np.ones((m, 1)))
    34.                 err_arr[predicted_vals == label_mat] = 0
    35.                 # 这里是矩阵乘法
    36.                 weighted_err = D.T * err_arr
    37.                 ''' dim 表示 feature列 thresh_val 表示树的分界值 inequal 表示计算树左右颠倒的错误率的情况 weighted_error 表示整体结果的错误率 best_class_est 预测的最优结果 （与class_labels对应） '''
    38.                 # print('split: dim {}, thresh {}, thresh inequal: {}, the weighted err is {}'.format(
    39.                 # i, thresh_val, inequal, weighted_err
    40.                 # ))
    41.                 if weighted_err < min_err:
    42.                     min_err = weighted_err
    43.                     best_class_est = predicted_vals.copy()#可以保存的结果集储存
    44.                     best_stump['dim'] = i# 第i列
    45.                     best_stump['thresh'] = thresh_val# 阈值
    46.                     best_stump['ineq'] = inequal#比较范围，是用大于还是用小于
    47.     # best_stump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少 (单个弱分类器)
    48.     # print(best_stump)
    49.     return best_stump, min_err, best_class_est
    50. # print(np.mat(np.ones((5,1))/5))#赋值相同的权重
    51. # [[0.2]
    52. # [0.2]
    53. # [0.2]
    54. # [0.2]
    55. # [0.2]]
    56. # print(build_stump(datMat,classLables,np.mat(np.ones((5,1))/5)))
    57. def ada_boost_train_ds(data_arr, class_labels, num_it=40):
    58.     """ adaBoost训练过程放大 :param data_arr: 特征标签集合 :param class_labels: 分类标签集合 :param num_it: 迭代次数 :return: weak_class_arr 弱分类器的集合 agg_class_est 预测的分类结果值 """
    59.     weak_class_arr = []
    60.     m = np.shape(data_arr)[0]
    61.     # 初始化 D，设置每个特征的权重值，平均分为m份
    62.     D = np.mat(np.ones((m, 1)) / m)
    63.     agg_class_est = np.mat(np.zeros((m, 1)))#初始化0矩阵
    64.     for i in range(num_it):
    65.         # 得到决策树的模型
    66.         best_stump, error, class_est = build_stump(data_arr, class_labels, D)# 寻找最佳的单层决策树
    67.         # print('D: {}'.format(D.T))
    68.         # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
    69.         # 计算每个分类器的 alpha 权重值
    70.         alpha = float(0.5 * np.log((1.0 - error) / max(error, 1e-16)))
    71.         best_stump['alpha'] = alpha
    72.         # store Stump Params in Array
    73.         weak_class_arr.append(best_stump)
    74.         # print('class_est: {}'.format(class_est.T))
    75.         # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
    76.         # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
    77.         expon = np.multiply(-1 * alpha * np.mat(class_labels).T, class_est)
    78.         # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式有问题
    79.         # print('(-1取反)预测值 expon=', expon.T)
    80.         # 计算e的expon次方，然后计算得到一个综合的概率的值
    81.         # 结果发现： 判断错误的样本，D对于的样本权重值会变大。
    82.         # multiply是对应项相乘
    83.         D = np.multiply(D, np.exp(expon))
    84.         D = D / D.sum()
    85.         # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
    86.         # print('叠加前的分类结果class_est: {}'.format(class_est.T))
    87.         agg_class_est += alpha * class_est
    88.         # print('叠加后的分类结果agg_class_est: {}'.format(agg_class_est.T))
    89.         # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
    90.         # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负，这里1就是表示是错误分辨的
    91.         agg_errors = np.multiply(np.sign(agg_class_est) != np.mat(class_labels).T,
    92.                                  np.ones((m, 1)))
    93.         error_rate = agg_errors.sum() / m
    94.         print('total error: {}\n'.format(error_rate))
    95.         if error_rate == 0.0:
    96.             break
    97.     # print(D)
    98.     return weak_class_arr,agg_class_est
    99. def loadDataSet(fileName):
    100.     numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    101.     dataMat = [];labelMat = []
    102.     fr = open(fileName)
    103.     for line in fr.readlines():
    104.         lineArr = []
    105.         curLine = line.strip().split('\t')
    106.         # 将21个特征保存起来
    107.         for i in range(numFeat-1):
    108.             lineArr.append((float(curLine[i])))
    109.         # print(len(lineArr))
    110.         dataMat.append(lineArr)
    111.         labelMat.append(float(curLine[-1]))
    112.     return dataMat,labelMat
    113. datArr,labelArr = loadDataSet(r'/home/ach/桌面/machine-learning/ai/Adaboost/7.AdaBoost/horseColicTraining2.txt')
    114. # print(ada_boost_train_ds(datArr,labelArr,10))
    115. classifiterArray,aggClassEst = ada_boost_train_ds(datArr,labelArr,100)
    116. def plot_roc(pred_strengths, class_labels):
    117.     """ (打印ROC曲线，并计算AUC的面积大小) :param pred_strengths: 最终预测结果的权重值 :param class_labels: 原始数据的分类结果集 :return: """
    118.     import matplotlib.pyplot as plt
    119.     # variable to calculate AUC
    120.     y_sum = 0.0
    121.     # 对正样本的进行求和
    122.     num_pos_class = np.sum(np.array(class_labels) == 1.0)
    123.     # 正样本的概率
    124.     y_step = 1 / float(num_pos_class)
    125.     # 负样本的概率
    126.     x_step = 1 / float(len(class_labels) - num_pos_class)
    127.     # np.argsort函数返回的是数组值从小到大的索引值
    128.     # get sorted index, it's reverse
    129.     sorted_indicies = pred_strengths.argsort()
    130.     # 测试结果是否是从小到大排列
    131.     # 可以选择打印看一下
    132.     # 开始创建模版对象
    133.     fig = plt.figure()
    134.     fig.clf()
    135.     ax = plt.subplot(111)
    136.     # cursor光标值
    137.     cur = (1.0, 1.0)
    138.     # loop through all the values, drawing a line segment at each point
    139.     for index in sorted_indicies.tolist()[0]:
    140.         if class_labels[index] == 1.0:
    141.             del_x = 0
    142.             del_y = y_step
    143.         else:
    144.             del_x = x_step
    145.             del_y = 0
    146.             y_sum += cur[1]
    147.         # draw line from cur to (cur[0]-delX, cur[1]-delY)
    148.         # 画点连线 (x1, x2, y1, y2)
    149.         # print cur[0], cur[0]-delX, cur[1], cur[1]-delY
    150.         ax.plot([cur[0], cur[0] - del_x], [cur[1], cur[1] - del_y], c='b')
    151.         cur = (cur[0] - del_x, cur[1] - del_y)
    152.     # 画对角的虚线线
    153.     ax.plot([0, 1], [0, 1], 'b--')
    154.     plt.xlabel('False positive rate')
    155.     plt.ylabel('True positive rate')
    156.     plt.title('ROC curve for AdaBoost horse colic detection system')
    157.     # 设置画图的范围区间 (x1, x2, y1, y2)
    158.     ax.axis([0, 1, 0, 1])
    159.     plt.show()
    160.     ''' 参考说明：http://blog.csdn.net/wenyusuran/article/details/39056013 为了计算 AUC ，我们需要对多个小矩形的面积进行累加。 这些小矩形的宽度是x_step，因此可以先对所有矩形的高度进行累加，最后再乘以x_step得到其总面积。 所有高度的和(y_sum)随着x轴的每次移动而渐次增加。 '''
    161.     print("the Area Under the Curve is: ", y_sum * x_step)
    162. 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):

    1. numFeat = len(open(fileName).readline().split('\t'))# 22个列 21个特征 1个标签
    2. dataMat = [];labelMat = []
    3. fr = open(fileName)
    4. for line in fr.readlines():
    5.     lineArr = []
    6.     curLine = line.strip().split('\t')
    7.     # 将21个特征保存起来
    8.     for i in range(numFeat-1):
    9.         lineArr.append((float(curLine[i])))
    10.     # print(len(lineArr))
    11.     dataMat.append(lineArr)
    12.     labelMat.append(float(curLine[-1]))
    13. 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))

发表评论

表情：
评论列表 （有 0 条评论，93人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Adaboost算法

    Adaboost算法 集成学习概述 集成学习算法定义 集成学习(Ensemble learning)就是讲若干个弱分类器通过一定策略组合后产生一个强分类

    港控/mmm°港控/mmm°/ 0 赞/ 94 阅读

    相关 集成学习之Adaboost算法

    （作者：陈玓玏） 一、Adaboost算法 我的理解集成学习的一大优点是，如果你想要学习一个很强的学习器，没有问题，但是很容易产生过拟合，但是如果你学习很多个弱的学习器

    傷城~傷城~/ 0 赞/ 322 阅读