第7章 集成方法 ensemble method

    • 概念：是对其他算法进行组合的一种形式。

    • 通俗来说： 当做重要决定时，大家可能都会考虑吸取多个专家而不只是一个人的意见。
      机器学习处理问题时又何尝不是如此？ 这就是集成方法背后的思想。

    • 集成方法：

      1. 投票选举(bagging: 自举汇聚法 bootstrap aggregating): 是基于数据随机重抽样分类器构造的方法
      2. 再学习(boosting): 是基于所有分类器的加权求和的方法

    目前 bagging 方法最流行的版本是: 随机森林(random forest)

    选男友：美女选择择偶对象的时候，会问几个闺蜜的建议，最后选择一个综合得分最高的一个作为男朋友

    目前 boosting 方法最流行的版本是: AdaBoost

    追女友：3个帅哥追同一个美女，第1个帅哥失败->(传授经验：姓名、家庭情况) 第2个帅哥失败->(传授经验：兴趣爱好、性格特点) 第3个帅哥成功

    1. bagging 是一种与 boosting 很类似的技术, 所使用的多个分类器的类型（数据量和特征量）都是一致的。
    2. bagging 是由不同的分类器（1.数据随机化 2.特征随机化）经过训练，综合得出的出现最多分类结果；boosting 是通过调整已有分类器错分的那些数据来获得新的分类器，得出目前最优的结果。
    3. bagging 中的分类器权重是相等的；而 boosting 中的分类器加权求和，所以权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。
    • 随机森林指的是利用多棵树对样本进行训练并预测的一种分类器。
    • 决策树相当于一个大师，通过自己在数据集中学到的知识用于新数据的分类。但是俗话说得好，一个诸葛亮，玩不过三个臭皮匠。随机森林就是希望构建多个臭皮匠，希望最终的分类效果能够超过单个大师的一种算法。

    随机森林 原理

    那随机森林具体如何构建呢？

    有两个方面：

    1. 数据的随机性化
    2. 待选特征的随机化

    使得随机森林中的决策树都能够彼此不同，提升系统的多样性，从而提升分类性能。

    数据的随机化：使得随机森林中的决策树更普遍化一点，适合更多的场景。

    （有放回的准确率在：70% 以上， 无放回的准确率在：60% 以上）

    1. 采取有放回的抽样方式 构造子数据集，保证不同子集之间的数量级一样（不同子集／同一子集 之间的元素可以重复）
    2. 利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。
    3. 然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
    4. 如下图，假设随机森林中有3棵子决策树，2棵子树的分类结果是A类，1棵子树的分类结果是B类，那么随机森林的分类结果就是A类。

    待选特征的随机化

    1. 子树从所有的待选特征中随机选取一定的特征。
    2. 在选取的特征中选取最优的特征。

    下图中，蓝色的方块代表所有可以被选择的特征，也就是目前的待选特征；黄色的方块是分裂特征。

    左边是一棵决策树的特征选取过程，通过在待选特征中选取最优的分裂特征（别忘了前文提到的ID3算法，C4.5算法，CART算法等等），完成分裂。

    右边是一个随机森林中的子树的特征选取过程。

    特征重抽样

    随机森林 开发流程

    随机森林 算法特点

    2. 缺点：劣势在于模型大小、是个很难去解释的黑盒子。
    3. 适用数据范围：数值型和标称型

    项目概述

    这是 Gorman 和 Sejnowski 在研究使用神经网络的声纳信号分类中使用的数据集。任务是训练一个模型来区分声纳信号。

    开发流程

    1. 收集数据：提供的文本文件
    2. 准备数据：转换样本集
    3. 分析数据：手工检查数据
    4. 训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
    5. 测试算法：在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分
    6. 使用算法：若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码

    收集数据：提供的文本文件

    样本数据：sonar-all-data.txt

    1. 0.02,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.066,0.2273,0.31,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.555,0.6711,0.6415,0.7104,0.808,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.051,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.018,0.0084,0.009,0.0032,R
    2. 0.0453,0.0523,0.0843,0.0689,0.1183,0.2583,0.2156,0.3481,0.3337,0.2872,0.4918,0.6552,0.6919,0.7797,0.7464,0.9444,1,0.8874,0.8024,0.7818,0.5212,0.4052,0.3957,0.3914,0.325,0.32,0.3271,0.2767,0.4423,0.2028,0.3788,0.2947,0.1984,0.2341,0.1306,0.4182,0.3835,0.1057,0.184,0.197,0.1674,0.0583,0.1401,0.1628,0.0621,0.0203,0.053,0.0742,0.0409,0.0061,0.0125,0.0084,0.0089,0.0048,0.0094,0.0191,0.014,0.0049,0.0052,0.0044,R
    3. 0.0262,0.0582,0.1099,0.1083,0.0974,0.228,0.2431,0.3771,0.5598,0.6194,0.6333,0.706,0.5544,0.532,0.6479,0.6931,0.6759,0.7551,0.8929,0.8619,0.7974,0.6737,0.4293,0.3648,0.5331,0.2413,0.507,0.8533,0.6036,0.8514,0.8512,0.5045,0.1862,0.2709,0.4232,0.3043,0.6116,0.6756,0.5375,0.4719,0.4647,0.2587,0.2129,0.2222,0.2111,0.0176,0.1348,0.0744,0.013,0.0106,0.0033,0.0232,0.0166,0.0095,0.018,0.0244,0.0316,0.0164,0.0095,0.0078,R

    准备数据：转换样本集

    1. # 导入csv文件
    2. def loadDataSet(filename):
    3.     dataset = []
    4.     with open(filename, 'r') as fr:
    5.         for line in fr.readlines():
    6.             if not line:
    7.                 continue
    8.             lineArr = []
    9.             for featrue in line.split(','):
    10.                 # strip()返回移除字符串头尾指定的字符生成的新字符串
    11.                 str_f = featrue.strip()
    12.                 if str_f.isdigit(): # 判断是否是数字
    13.                     # 将数据集的第column列转换成float形式
    14.                     lineArr.append(float(str_f))
    15.                 else:
    16.                     # 添加分类标签
    17.                     lineArr.append(str_f)
    18.             dataset.append(lineArr)
    19.     return dataset
    • 样本数据随机无放回抽样-用于交叉验证
    1. def cross_validation_split(dataset, n_folds):
    2.     """cross_validation_split(将数据集进行抽重抽样 n_folds 份，数据可以重复抽取)
    4.     Args:
    5.         dataset     原始数据集
    6.         n_folds     数据集dataset分成n_flods份
    7.     Returns:
    8.         dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复抽取
    9.     """
    10.     dataset_split = list()
    11.     dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变
    12.     fold_size = len(dataset) / n_folds
    13.     for i in range(n_folds):
    14.         fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_split
    15.         while len(fold) < fold_size:   # 这里不能用 if，if 只是在第一次判断时起作用，while 执行循环，直到条件不成立
    16.             # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此为自助采样法。从而保证每棵决策树训练集的差异性            
    17.             index = randrange(len(dataset_copy))
    18.             # 将对应索引 index 的内容从 dataset_copy 中导出，并将该内容从 dataset_copy 中删除。
    19.             # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
    20.             fold.append(dataset_copy.pop(index))  # 无放回的方式
    21.             # fold.append(dataset_copy[index])  # 有放回的方式
    22.         dataset_split.append(fold)
    23.     # 由dataset分割出的n_folds个数据构成的列表，为了用于交叉验证
    24.     return dataset_split
    • 训练数据集随机化
    • 特征随机化
    1. # 找出分割数据集的最优特征，得到最优的特征 index，特征值 row[index]，以及分割完的数据 groups（left, right）
    2. def get_split(dataset, n_features):
    3.     class_values = list(set(row[-1] for row in dataset))  # class_values =[0, 1]
    4.     b_index, b_value, b_score, b_groups = 999, 999, 999, None
    5.     features = list()
    6.         index = randrange(len(dataset[0])-1)  # 往 features 添加 n_features 个特征（ n_feature 等于特征数的个数），特征索引从 dataset 中随机取
    7.         if index not in features:
    8.             features.append(index)
    9.     for index in features:                    # 在 n_features 个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
    10.         for row in dataset:
    11.             groups = test_split(index, row[index], dataset)  # groups=(left, right), row[index] 遍历每一行 index 索引下的特征值作为分类值 value, 找出最优的分类特征和特征值
    12.             gini = gini_index(groups, class_values)
    13.             # 左右两边的数量越一样，说明数据区分度不高，gini系数越大
    14.             if gini < b_score:
    15.                 b_index, b_value, b_score, b_groups = index, row[index], gini, groups  # 最后得到最优的分类特征 b_index,分类特征值 b_value,分类结果 b_groups。b_value 为分错的代价成本
    16.     # print b_score
    17.     return {'index': b_index, 'value': b_value, 'groups': b_groups}
    • 随机森林
    1. # Random Forest Algorithm
    2. def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
    3.     """random_forest(评估算法性能，返回模型得分)
    5.     Args:
    6.         train           训练数据集
    7.         test            测试数据集
    8.         max_depth       决策树深度不能太深，不然容易导致过拟合
    9.         min_size        叶子节点的大小
    10.         sample_size     训练数据集的样本比例
    11.         n_trees         决策树的个数
    13.     Returns:
    14.         predictions     每一行的预测结果，bagging 预测最后的分类结果
    15.     """
    17.     trees = list()
    18.     # n_trees 表示决策树的数量
    19.     for i in range(n_trees):
    20.         # 随机抽样的训练样本， 随机采样保证了每棵决策树训练集的差异性
    21.         sample = subsample(train, sample_size)
    22.         # 创建一个决策树
    23.         tree = build_tree(sample, max_depth, min_size, n_features)
    24.         trees.append(tree)
    26.     # 每一行的预测结果，bagging 预测最后的分类结果
    27.     predictions = [bagging_predict(trees, row) for row in test]
    28.     return predictions

    测试算法：在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分。

    • 计算随机森林的预测结果的正确率
    1. # 评估算法性能，返回模型得分
    2. def evaluate_algorithm(dataset, algorithm, n_folds, *args):
    3.     """evaluate_algorithm(评估算法性能，返回模型得分)
    5.     Args:
    6.         dataset     原始数据集
    7.         algorithm   使用的算法
    8.         n_folds     数据的份数
    9.         *args       其他的参数
    10.     Returns:
    11.         scores      模型得分
    12.     """
    14.     # 将数据集进行随机抽样，分成 n_folds 份，数据无重复的抽取
    15.     folds = cross_validation_split(dataset, n_folds)
    16.     scores = list()
    17.     # 每次循环从 folds 从取出一个 fold 作为测试集，其余作为训练集，遍历整个 folds ，实现交叉验证
    18.     for fold in folds:
    19.         train_set = list(folds)
    20.         train_set.remove(fold)
    21.         # 将多个 fold 列表组合成一个 train_set 列表, 类似 union all
    22.         """
    23.         In [20]: l1=[[1, 2, 'a'], [11, 22, 'b']]
    24.         In [21]: l2=[[3, 4, 'c'], [33, 44, 'd']]
    25.         In [22]: l=[]
    26.         In [23]: l.append(l1)
    27.         In [24]: l.append(l2)
    28.         In [25]: l
    29.         Out[25]: [[[1, 2, 'a'], [11, 22, 'b']], [[3, 4, 'c'], [33, 44, 'd']]]
    30.         In [26]: sum(l, [])
    31.         Out[26]: [[1, 2, 'a'], [11, 22, 'b'], [3, 4, 'c'], [33, 44, 'd']]
    32.         """
    33.         train_set = sum(train_set, [])
    34.         test_set = list()
    35.         # fold 表示从原始数据集 dataset 提取出来的测试集
    36.         for row in fold:
    37.             row_copy = list(row)
    38.             row_copy[-1] = None 
    39.             test_set.append(row_copy)
    40.         predicted = algorithm(train_set, test_set, *args)
    41.         actual = [row[-1] for row in fold]
    43.         # 计算随机森林的预测结果的正确率
    44.         accuracy = accuracy_metric(actual, predicted)
    45.         scores.append(accuracy)
    46.     return scores

    使用算法：若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码

    : https://github.com/apachecn/MachineLearning/blob/master/src/py2.x/7.RandomForest/randomForest.py

    AdaBoost (adaptive boosting: 自适应 boosting) 概述

    能否使用弱分类器和多个实例来构建一个强分类器？ 这是一个非常有趣的理论问题。

    AdaBoost 工作原理

    AdaBoost 开发流程

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

    AdaBoost 算法特点

    1. * 优点：泛化（由具体的、个别的扩大为一般的）错误率低，易编码，可以应用在大部分分类器上，无参数调节。
    2. * 缺点：对离群点敏感。
    3. * 适用数据类型：数值型和标称型数据。

    项目案例: 马疝病的预测

    项目流程图

    AdaBoost代码流程图

    基于单层决策树构建弱分类器

    • 单层决策树(decision stump, 也称决策树桩)是一种简单的决策树。

    项目概述

    开发流程

    训练数据：horseColicTraining.txt

    测试数据：horseColicTest.txt

    1. 2.000000    1.000000    38.500000    66.000000    28.000000    3.000000    3.000000    0.000000    2.000000    5.000000    4.000000    4.000000    0.000000    0.000000    0.000000    3.000000    5.000000    45.000000    8.400000    0.000000    0.000000    -1.000000
    2. 1.000000    1.000000    39.200000    88.000000    20.000000    0.000000    0.000000    4.000000    1.000000    3.000000    4.000000    2.000000    0.000000    0.000000    0.000000    4.000000    2.000000    50.000000    85.000000    2.000000    2.000000    -1.000000
    3. 2.000000    1.000000    38.300000    40.000000    24.000000    1.000000    1.000000    3.000000    1.000000    3.000000    3.000000    1.000000    0.000000    0.000000    0.000000    1.000000    1.000000    33.000000    6.700000    0.000000    0.000000    1.000000

    准备数据：确保类别标签是+1和-1，而非1和0

    1. def loadDataSet(fileName):
    2.     numFeat = len(open(fileName).readline().split('\t'))
    3.     dataArr = []
    4.     labelArr = []
    5.     fr = open(fileName)
    7.         lineArr = []
    8.         curLine = line.strip().split('\t')
    9.         for i in range(numFeat-1):
    10.             lineArr.append(float(curLine[i]))
    11.         dataArr.append(lineArr)
    12.         labelArr.append(float(curLine[-1]))
    13.     return dataArr, labelArr

    分析数据：统计分析

    过拟合(overfitting, 也称为过学习)

    • 发现测试错误率在达到一个最小值之后有开始上升，这种现象称为过拟合。

    • 通俗来说：就是把一些噪音数据也拟合进去的，如下图。

    过拟合

    训练算法：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器

    1. def adaBoostTrainDS(dataArr, labelArr, numIt=40):
    2.     """adaBoostTrainDS(adaBoost训练过程放大)
    3.     Args:
    4.         dataArr   特征标签集合
    5.         labelArr  分类标签集合
    6.         numIt     实例数
    7.     Returns:
    8.         weakClassArr  弱分类器的集合
    9.         aggClassEst   预测的分类结果值
    10.     """
    11.     weakClassArr = []
    12.     m = shape(dataArr)[0]
    13.     # 初始化 D，设置每个样本的权重值，平均分为m份
    14.     D = mat(ones((m, 1))/m)
    15.     aggClassEst = mat(zeros((m, 1)))
    16.     for i in range(numIt):
    17.         # 得到决策树的模型
    18.         bestStump, error, classEst = buildStump(dataArr, labelArr, D)
    20.         # alpha目的主要是计算每一个分类器实例的权重(组合就是分类结果)
    21.         # 计算每个分类器的alpha权重值
    22.         alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))
    23.         bestStump['alpha'] = alpha
    24.         # store Stump Params in Array
    25.         weakClassArr.append(bestStump)
    27.         print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
    28.         # 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
    29.         # 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
    30.         expon = multiply(-1*alpha*mat(labelArr).T, classEst)
    31.         print '(-1取反)预测值expon=', expon.T
    32.         # 计算e的expon次方，然后计算得到一个综合的概率的值
    33.         # 结果发现： 判断错误的样本，D中相对应的样本权重值会变大。
    34.         D = multiply(D, exp(expon))
    35.         D = D/D.sum()
    37.         # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
    38.         print '当前的分类结果：', alpha*classEst.T
    39.         aggClassEst += alpha*classEst
    40.         print "叠加后的分类结果aggClassEst: ", aggClassEst.T
    41.         # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
    42.         # 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
    43.         aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))
    44.         errorRate = aggErrors.sum()/m
    45.         # print "total error=%s " % (errorRate)
    46.         if errorRate == 0.0:
    47.             break
    48.     return weakClassArr, aggClassEst
    1. 发现：
    2. alpha （模型权重）目的主要是计算每一个分类器实例的权重(加和就是分类结果)
    3.   分类的权重值：最大的值= alpha 的加和，最小值=-最大值
    4. D （样本权重）的目的是为了计算错误概率： weightedError = D.T*errArr，求最佳分类器
    5.   样本的权重值：如果一个值误判的几率越小，那么 D 的样本权重越小

    测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。

    1. def adaClassify(datToClass, classifierArr):
    2.     """adaClassify(ada分类测试)
    3.     Args:
    4.         datToClass     多个待分类的样例
    5.         classifierArr  弱分类器的集合
    6.     Returns:
    7.         sign(aggClassEst) 分类结果
    8.     """
    9.     # do stuff similar to last aggClassEst in adaBoostTrainDS
    10.     dataMat = mat(datToClass)
    11.     m = shape(dataMat)[0]
    12.     aggClassEst = mat(zeros((m, 1)))
    14.     # 循环 多个分类器
    15.     for i in range(len(classifierArr)):
    16.         # 前提： 我们已经知道了最佳的分类器的实例
    17.         # 通过分类器来核算每一次的分类结果，然后通过alpha*每一次的结果 得到最后的权重加和的值。
    18.         classEst = stumpClassify(dataMat, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])
    19.         aggClassEst += classifierArr[i]['alpha']*classEst
    20.     return sign(aggClassEst)

    使用算法：观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去。

    : https://github.com/apachecn/MachineLearning/blob/master/src/py2.x/7.AdaBoost/adaboost.py

    要点补充

    非均衡现象：

    在分类器训练时，正例数目和反例数目不相等（相差很大）。或者发生在正负例分类错误的成本不同的时候。

    • 判断马是否能继续生存(不可误杀)
    • 过滤垃圾邮件(不可漏判)
    • 不能放过传染病的人
    • 不能随便认为别人犯罪

    我们有多种方法来处理这个问题： 具体可参考

    再结合书中的方法，可以归为八大类：

    1.能否收集到更多的数据？

    这个措施往往被人们所忽略，被认为很蠢。但是更大的数据集更能体现样本的分布，多样性。

    2.尝试使用其他的评价指标

    Accuracy 或者error rate 不能用于非均衡的数据集。这会误导人。这时候可以尝试其他的评价指标。

    Confusion Matrix 混淆矩阵：使用一个表格对分类器所预测的类别与其真实的类别的样本统计，分别为：TP、FN、FP与TN。

    Precision：精确度

    Recall： 召回率

    F1 Score (or F-Score)： 精确度和召回率的加权平均

    或者使用

    Kappa (Cohen’s kappa)

    ROC Curves

    • ROC 曲线: 最佳的分类器应该尽可能地处于左上角

    ROC曲线

    • 对不同的 ROC 曲线进行比较的一个指标是曲线下的面积(Area Unser the Curve, AUC).

    • AUC 给出的是分类器的平均性能值，当然它并不能完全代替对整条曲线的观察。

    • 一个完美分类器的 AUC 为1，而随机猜测的 AUC 则为0.5。

    3.尝试对样本重抽样

    欠抽样(undersampling)或者过抽样(oversampling)

    1. - 欠抽样: 意味着删除样例
    2. - 过抽样: 意味着复制样例(重复使用)

    对大类进行欠抽样

    或者结合上述两种方法进行抽样

    一些经验法则：

    • 考虑样本（超过1万、十万甚至更多）进行欠采样，即删除部分样本；

    • 考虑样本（不足1为甚至更少）进行过采样，即添加部分样本的副本；

    • 考虑尝试随机采样与非随机采样两种采样方法；

    • 考虑对各类别尝试不同的采样比例，不一定是1:1

    • 考虑同时使用过采样与欠采样

    4.尝试产生人工生成的样本

    一种简单的方法就是随机抽样小类样本的属性（特征）来组成新的样本即属性值随机采样。你可以根据经验进行抽样，可以使用其他方式比如朴素贝叶斯方法假设各属性之间互相独立进行采样，这样便可得到更多的数据，但是无法保证属性之间的非线性关系。

    当然也有系统性的算法。最常用的SMOTE(Synthetic Minority Over-Sampling Technique)。 顾名思义，这是一种over sampling（过抽样）的方式。它是产生人为的样本而不是制造样本副本。这个算法是选取2个或者2个以上相似的样本（根据距离度量 distance measure），然后每次选择其中一个样本，并随机选择一定数量的邻居样本对选择的那个样本的一个属性增加噪声(每次只处理一个属性)。这样就构造了更多的新生数据。具体可以参见原始论文。

    python实现可以查阅

    5.尝试不同的算法

    强烈建议不要在每个问题上使用你最喜欢的算法。虽然这个算法带来较好的效果，但是它也会蒙蔽你观察数据内蕴含的其他的信息。至少你得在同一个问题上试试各种算法。具体可以参阅Why you should be Spot-Checking Algorithms on your Machine Learning Problems

    比如说，决策树经常在非均衡数据集上表现良好。创建分类树时候使用基于类变量的划分规则强制使类别表达出来。如果有疑惑，可以尝试一些流行的决策树，比如, C4.5, C5.0, CART 和 Random Forrest。

    6.尝试使用惩罚的模型

    你可以使用同种算法但是以不同的角度对待这个问题。

    惩罚的模型就是对于不同的分类错误给予不同的代价（惩罚）。比如对于错分的小类给予更高的代价。这种方式会使模型偏差，更加关注小类。

    通常来说这种代价/惩罚或者比重在学习中算法是特定的。比如使用代价函数来实现：

    代价函数

    • 基于代价函数的分类器决策控制：

    这种方式叫做 cost sensitive learning，Weka 中相应的框架可以实现叫

    如果当你只能使用特定算法而且无法重抽样，或者模型效果不行，这时候使用惩罚（penalization）是可行的方法。这提供另外一种方式来“平衡”类别。但是设定惩罚函数/代价函数是比较复杂的。最好还是尝试不同的代价函数组合来得到最优效果。

    7.尝试使用不同的角度

    其实有很多研究关于非均衡数据。他们有自己的算法，度量，术语。

    从它们的角度看看你的问题，思考你的问题，说不定会有新的想法。

    两个领域您可以考虑： anomaly detection(异常值检测) 和 change detection（变化趋势检测）。

    Anomaly dectection 就是检测稀有事件。 比如通过机器震动来识别机器谷中或者根据一系列系统的调用来检测恶意操作。与常规操作相比，这些事件是罕见的。

    把小类想成异常类这种转变可能会帮助你想到新办法来分类数据样本。

    change detection 变化趋势检测类似于异常值检测。但是他不是寻找异常值而是寻找变化或区别。比如通过使用模式或者银行交易记录来观察用户行为转变。

    这些两种转变可能会给你新的方式去思考你的问题和新的技术去尝试。

    8.尝试去创新

    仔细思考你的问题然后想想看如何将这问题细分为几个更切实际的小问题。

    比如：

    将你的大类分解成多个较小的类；

    使用One Class分类器（看待成异常点检测）；

    对数据集进行抽样成多个数据集，使用集成方式，训练多个分类器，然后联合这些分类器进行分类；

    这只是一个例子。更多的可以参阅In classification, how do you handle an unbalanced training set? 和

    • 作者：片刻
    • 版权声明：欢迎转载学习 => 请标注信息来源于