精华内容
下载资源
问答
  • 不平衡数据集处理方法

    万次阅读 多人点赞 2018-11-04 12:59:50
    1、不平衡(均衡)数据集 (1)不平衡数据集定义 (2)不平衡数据集举例 (3)不平衡数据集实例 (4)不平衡数据集导致的问题 (5)不平衡数据集的主要处理方法 2、不平衡(均衡)数据集常用的处理方法 (1)...

    目录

    1、不平衡(均衡)数据集

    (1)不平衡数据集定义

    (2)不平衡数据集举例

    (3)不平衡数据集实例

    (4)不平衡数据集导致的问题

    (5)不平衡数据集的主要处理方法

    2、不平衡(均衡)数据集常用的处理方法

    (1)扩充数据集

    (2)对数据集进行重采样

    (3)人造数据

    (4)改变分类算法

    3、将数据集划分为训练数据集和测试数据集

    4、使用K折交叉验证评估模型性能

    (1)K折交叉验证

    (2)分层k折交叉验证


    1、不平衡(均衡)数据集

    (1)不平衡数据集定义

    不平衡数据集指的是数据集各个类别的样本数目相差巨大。以二分类问题为例,假设正类的样本数量远大于负类的样本数量,这种情况下的数据称为不平衡数据

    (2)不平衡数据集举例

    ① 在二分类问题中,训练集中class 1的样本数比上class 2的样本数的比值为60:1。使用逻辑回归进行分类,最后结果是其忽略了class 2,将所有的训练样本都分类为class 1。

    ② 在三分类问题中,三个类别分别为A,B,C,训练集中A类的样本占70%,B类的样本占25%,C类的样本占5%。最后我的分类器对类A的样本过拟合了,而对其它两个类别的样本欠拟合。

    (3)不平衡数据集实例

    训练数据不均衡是常见并且合理的情况,比如:

    ① 在欺诈交易识别中,绝大部分交易是正常的,只有极少部分的交易属于欺诈交易。

    ② 在客户流失问题中,绝大部分的客户是会继续享受其服务的(非流失对象),只有极少数部分的客户不会再继续享受其服务(流失对象)。

    (4)不平衡数据集导致的问题

    如果训练集的90%的样本是属于同一个类的,而我们的分类器将所有的样本都分类为该类,在这种情况下,该分类器是无效的,尽管最后的分类准确度为90%。所以在数据不均衡时,准确度(Accuracy)这个评价指标参考意义就不大了。实际上,如果不均衡比例超过4:1,分类器就会偏向于大的类别。

    (5)不平衡数据集的主要处理方法

    ① 从数据的角度出发,主要方法为采样,分为欠采样过采样以及对应的一些改进方法。

    ② 从算法的角度出发,考虑不同误分类情况代价的差异性对算法进行优化,主要是基于代价敏感学习算法(Cost-Sensitive Learning),代表的算法有adacost。

    另外可以将不平衡数据集的问题考虑为一分类(One Class Learning)或者异常检测(Novelty Detection)问题,代表的算法有One-class SVM。

    从数据角度出发的不平衡数据集的处理方法对应的python库(imblearn)

    不平衡数据的学习即需要在分布不均匀的数据集中学习到有用的信息。

    2、不平衡(均衡)数据集常用的处理方法

    (1)扩充数据集

    首先想到能否获得更多数据,尤其是小类(该类样本数据极少)的数据,更多的数据往往能得到更多的分布信息。

    (2)对数据集进行重采样

    过采样(over-sampling)

    对小类的数据样本进行过采样来增加小类的数据样本个数,即采样的个数大于该类样本的个数。

    # -*- coding: utf-8 -*-
    from imblearn.over_sampling import RandomOverSampler
    ros=RandomOverSampler(random_state=0) #采用随机过采样(上采样)
    x_resample,y_resample=ros.fit_sample(trainset,labels)

    欠采样(under-sampling)

    对大类的数据样本进行欠采样来减少大类的数据样本个数,即采样的个数少于该类样本的个数。

    采样算法容易实现,效果也不错,但可能增大模型的偏差(Bias),因为放大或者缩小某些样本的影响相当于改变了原数据集的分布。对不同的类别也要采取不同的采样比例,但一般不会是1:1,因为与现实情况相差甚远,压缩大类的数据是个不错的选择。

    # -*- coding: utf-8 -*-
    from imblearn.under_sampling import RandomUnderSampler
    #通过设置RandomUnderSampler中的replacement=True参数, 可以实现自助法(boostrap)抽样
    #通过设置RandomUnderSampler中的rratio参数,可以设置数据采样比例
    rus=RandomUnderSampler(ratio=0.4,random_state=0,replacement=True) #采用随机欠采样(下采样)
    x_resample,y_resample=rus.fit_sample(trainset,labels)

    (3)人造数据

    ① 属性值随机采样

    在该类下所有样本的每个属性特征的取值空间中随机选取一个组成新的样本,即属性值随机采样。此方法多用于小类中的样本,不过它可能破坏原属性的线性关系。如在图像中,对一幅图像进行扭曲得到另一幅图像,即改变了原图像的某些特征值,但是该方法可能会产生现实中不存在的样本。

    ② SMOTE(Synthetic Minority Over-sampling Technique)

    SMOTE是一种过采样算法,它构造新的小类样本而不是产生小类中已有的样本的副本。它基于距离度量选择小类别下两个或者更多的相似样本,然后选择其中一个样本,并随机选择一定数量的邻居样本对选择的那个样本的一个属性增加噪声,每次处理一个属性。这样就构造了许多新数据。

    (4)改变分类算法

    ① 使用代价函数时,可以增加小类样本的权值,降低大类样本的权值(这种方法其实是产生了新的数据分布,即产生了新的数据集),从而使得分类器将重点集中在小类样本身上。刚开始,可以设置每个类别的权值与样本个数比例的倒数,然后可以使用过采样进行调优。

    ② 可以把小类样本作为异常点(outliers),把问题转化为异常点检测问题(anomaly detection)。此时分类器需要学习到大类的决策分界面,即分类器是一个单个类分类器(One Class Classifier)。

    ③ 由Robert E. Schapire提出的”The strength of weak learnability”方法,该方法是一个boosting算法,它递归地训练三个弱学习器,然后将这三个弱学习器结合起形成一个强的学习器。

    3、将数据集划分为训练数据集和测试数据集

    # -*- coding: utf-8 -*-
    from collections import Counter
    from sklearn.model_selection import train_test_split  #数据集划分
    #参数test_size表示数据集和测试集的划分比例
    x_train,x_test,y_train,y_test = train_test_split(datasets,labels,test_size=0.1,random_state=0) #数据集划分
    print(len(x_train))
    print(len(x_test))
    print(Counter(x_train))#统计训练集中不同类别的数量

    4、使用K折交叉验证评估模型性能

    (1)K折交叉验证

    在k折交叉验证中,我们不重复地随机将训练数据集划分为k个,其中k-1个用于模型的训练,剩余的1个用于测试。重复此过程k次,我们就得到了k个模型及对模型性能的评价。

    k折交叉验证的一个特例就是留一(leave-one-out,LOO)交叉验证法。在LOO中,我们将数据子集划分的数量等同于样本数(k=n),这样每次只有一个样本用于测试。当数据集非常小时,建议使用此方法进行验证。

    # -*- coding: utf-8 -*-
    from sklearn.model_selection import KFold   #交叉验证
    import numpy as np
    kf=KFold(n_splits=10)
    for train_index,test_index in kf.split(datasets,labels):
        x_train = np.array(datasets)[train_index]
        y_train = np.array(datasets)[train_index]
        x_test = np.array(datasets)[test_index]
        y_test = np.array(labels)[test_index]

    (2)分层k折交叉验证

    分层k折交叉验证对标准k折交叉验证做了稍许改进,它可以获得偏差和方差都较低的评估结果,特别是类别比例相差较大时。在分层交叉验证中,类别比例在每个分块中得以保持,这使得每个分块中的类别比例与训练数据集的整体比例一致。(分层k折交叉验证参考论文)

    # -*- coding: utf-8 -*-
    from sklearn.model_selection import StratifiedKFold #分层k折交叉验证
    import numpy as np
    kf = StratifiedKFold(n_splits=10, shuffle=True)
    for train_index, test_index in kf.split(datasets, labels):
        x_train = np.array(datasets)[train_index]
        y_train = np.array(datasets)[train_index]
        x_test = np.array(datasets)[test_index]
        y_test = np.array(labels)[test_index]

     

     

     

     

     

    参考文献:

    【1】 机器学习︱非平衡数据处理方式与评估

    【2】分类中的训练数据集不均衡问题处理

    【3】不均衡学习的抽样方法

    【4】不均衡数据的机器学习

    【5】imblearn不平衡算法学习

     

    展开全文
  • 数据集分类不平衡的影响与处理

    千次阅读 2020-05-14 23:26:21
    本文介绍了机器学习、深度学习建模时,分类不平衡的影响和处理方法。


    不平衡分类对预测建模提出了挑战,因为用于分类的大多数机器学习算法都是围绕每个类别的样本数量均相等的假设来设计的。这导致模型的预测性能较差,特别是针对样本较少类别的预测。这是构建数据集需要考虑的一个问题,通常数量较少的类别更重要,因为与数量较多的类别来说,模型对样本较少的分类错误更为敏感。


    1. 分类预测建模

    分类问题是预测建模问题,涉及为每个观察值分配一个类别标签。分类模型会生成预测的类别,输出是离散的值。对于大多数实际应用,模型会通过softmax函数输出每一个类别的概率,然后选取置信度(概率)最大的类别输出。

    当描述问题时,预测建模问题的类别数通常是固定的,并且类别数通常不会改变。与回归模型一样,分类模型会产生连续值的预测,该预测通常以概率的形式出现(即,任何单个样本的类成员的预测值在0到1之间,且总和为1)。

    在处理分类预测建模问题时,必须收集训练数据集。分类问题中的数据由样本和标签组成。训练数据集是来自领域的许多示例,包括输入数据(例如,测量值)和输出数据(例如,类别标签)。训练数据集用于更好地理解输入数据,以帮助最佳地进行建模准备。它还用于评估一组不同的建模算法。它用于调整所选模型的超参数。最后,训练数据集用于在所有可用数据上训练最终模型,可以使用这些模型对新的数据进行预测。


    2. 不平衡分类

    属于每个类别的示例的数量称为类别分布。不平衡分类是指分类预测建模问题,其中训练数据集中每个类标签的示例数不平衡。也就是说,数据集中,每类样本的数量不相等。当一个或多个类别在训练数据中所占的比例低于其它类别时,就会出现不平衡。

    描述数据集中类的不平衡的另一种方法是将类分布总结为训练数据集的百分比。例如,不平衡的多类分类问题可能在第一类中有80%的示例,在第二类中有18%的示例,在第三类中有2%的示例。


    3. 分类失衡的原因

    不平衡的分类预测建模问题中类分布的不平衡可能有很多原因。导致失衡的两个主要原因,分别是数据采样和属性。跨类别的示例中的不平衡可能是由于从问题域中收集或采样示例的方式引起的。这可能涉及在数据收集过程中引入的偏差,以及在数据收集过程中发生的错误。比如偏差采样和测量误差。

    例如,示例可能是从狭窄的地理区域或某个时间段收集的,而类别的分布可能完全不同,甚至可能以不同的方式收集。

    收集观测值时可能会出错。一种错误类型可能是将错误的类标签应用于许多示例。或者,从中收集示例的过程或系统可能已损坏或受损,从而导致不平衡。

    通常,在不平衡是由采样偏差或测量误差引起的情况下,可以通过改进的采样方法或校正测量误差来校正不平衡。这是因为训练数据集不能正确的表示要解决的问题域。


    4. 分类失衡的挑战

    分类不平衡因问题而异。分类问题可能存在轻微的不平衡或者会存在严重的失衡,比如其中一个类中可能有数百或数千个示例,而另一类中可能有数十个示例。

    轻微失衡:一个不平衡的分类问题,其中样本的分布在训练数据集中很少(例如4:6)。
    严重失衡:在训练数据集中大量的示例分布不均匀的不平衡分类问题(例如1:100或更多)。

    现在大多数分类失衡的数据集都集中在1:4至1:100的失衡比率上。在欺诈检测或化学信息学等现实应用中,可能会处理不平衡率从1:1000到1:5000的问题。轻微的不平衡通常不是问题,并且可以像正常分类预测建模问题一样对待。严重不平衡可能很难建模,需要使用专门的技术。

    具有大量示例的一个或多个类称为主要或多数类,而具有少量示例(通常只有一个)的类称为次要或少数类。当处理分类不平衡问题时,通常最关注样本数较少的类别。这意味着模型正确预测少数样本的类别标签的能力比多数样本更为重要。

    少数派类别很难预测,因为按照定义,此类类别的例子很少。这意味着模型要学习此类中的示例的特征,并将此类中的示例与多数类(或多个类)区分开来更具挑战性。

    针对分类预测模型的大多数机器学习算法都是在假设类均等分布的问题上进行设计和演示的。这意味着模型可能只专注于学习大量观测的特征,而忽略了少数类别中实际上更受关注且其预测更有价值的示例。大多数分类算法的学习过程通常偏向多数类示例,因此少数类算法无法很好地建模到最终系统中。

    尽管在过去的二十年中,人们在学习失衡方面做了大量工作,但现有方法和问题仍有许多缺点有待解决。


    5. 分类失衡的例子

    下面列出了该问题领域的十个示例,其中示例的类分布固有地不平衡。

    • 欺诈识别。
    • 索赔预测
    • 默认预测。
    • 流失预测。
    • 垃圾邮件检测。
      异常检测。
    • 离群值检测。
    • 入侵检测
    • 转换预测。

    实例列表阐明了不平衡分类预测建模的性质。

    这些问题领域中的每一个都代表了整个研究领域,每个领域中的特定问题都可以作为不平衡的分类预测建模加以构架和探索。这凸显了类不平衡分类的多学科性质,以及为什么对于机器学习从业者来说,意识到这一问题并熟练地解决这一问题如此重要。


    6.解决方法

    算法方法:机器学习算法对假阳性和假阴性的惩罚相同。一种应对方法是修改算法本身,以提高少数群体类别的预测性能。这可以通过基于识别的学习或成本敏感的学习来执行。 Drummond & Holte (2003); Elkan (2001); Manevitz & Yousef (2001)

    数据方法:包括对数据进行重新采样以减轻类不平衡导致的影响。数据方法更灵活并允许使用最新算法,因此已在实践中广为接受。两种最常见的技术是过采样和欠采样。

    • 过采样,会增加训练集中少数群体成员的数量。过采样的优点是不会保留原始训练集中的信息,因为会保留少数和多数类别的所有观察结果。另一方面,它容易过度拟合。

    • 欠采样,与过采样相反,旨在减少多数样本的数量来平衡类分布。由于它正在从原始数据集中删除观察结果,因此可能会丢弃有用的信息。
      在这里插入图片描述
      之前一篇文章中介绍了设置class_weight实现类别的平衡的方法。此外还常使用过采样和欠采样方法。常用的方法有:

    • EditedNearestNeighbours欠采样技术(E2_ENN)

    • NearMiss 3 欠采样技术(E3_NM)

    • SMOTE过采样技术(E4_SMT)

    • ADASYN过采样技术(E5_ADS)

    • EditedNearestNeighbours & “Balanced” class_weight (E6_ENN)

    • NearMiss 3 & “Balanced” class_weight (E7_NM)

    • SMOTE & “Balanced” class_weight (E8_SMT)

    • ADASYN & “Balanced” class_weight (E9_ADS)


    7. 混淆矩阵,精度,召回率和F1分数

    在这里插入图片描述
    一类的F1分数为精度(查准率,precision)和查全率(召回率,recall)的调和平均值(2×精度×查全率/(精度+查全率))

    **对于给定的类,召回率和精度的不同组合具有以下含义:

    • 高召回率+高精度:模型可以完美地处理类
    • 召回率低+精度高:该模型无法很好地检测到类别,但在进行分类时是高度可信赖的
    • 召回率高+精度低:可以很好地检测类别,但是模型中也包含其他类别的点
    • 召回率低+精度低:模型处理不佳**

    https://link.springer.com/article/10.1007/s13748-016-0094-0
    https://medium.com/james-blogs/handling-imbalanced-data-in-classification-problems-7de598c1059f
    https://machinelearningmastery.com/what-is-imbalanced-classification/
    https://towardsdatascience.com/handling-imbalanced-datasets-in-machine-learning-7a0e84220f28

    展开全文
  • 许多二分类任务并不是每个类别都有相同数量的数据,存在着数据分布不平衡的情况。 一个常用的例子是成人收入数据集,...针对这一数据集,可以使用很多不平衡分类的相关算法完成分类任务。 在本教程中,您将了解如...

    许多二分类任务并不是每个类别都有相同数量的数据,存在着数据分布不平衡的情况。

    一个常用的例子是成人收入数据集,它涉及到社交关系、教育水平等个人数据,以此来预测成人的收入水平,判断其是否拥有5万美元/年的个人收入。数据集中个人收入低于5万美元的数据比高于5万美元的数据要明显多一些,存在着一定程度的分布不平衡。
    针对这一数据集,可以使用很多不平衡分类的相关算法完成分类任务。

    在本教程中,您将了解如何为数据分布不平衡的成人收入数据集开发分类模型并对其进行评估。

    学习本教程后,您将知道:

    • 如何加载和分析数据集,并对如何进行数据预处理和模型选择有一定启发。
    • 如何使用一个稳健的测试工具系统地评估机器学习模型的效能。
    • 如何拟合最终模型并使用它预测特定情况所对应的类标签。

    针对成人收入不平衡分类的具体内容如下:

    教程大纲

    本教程主要分为了以下五个部分:

    1. 成人收入数据集介绍
    2. 数据集分析
    3. 基础模型和性能评价
    4. 模型评价
    5. 对新输入数据进行预测

    成人收入数据集介绍

    在这个教程中,我们将使用一个数据分布不平衡的机器学习常用数据集,称为“成人收入”或简称“成人”数据集。
    该数据集归Ronny Kohavi和Barry Becker所有,取自1994年美国人口普查局的数据,包含有教育水平等个人详细数据,用于预测个人年收入是否超过或低于50000美元。
    数据集提供14个输入变量,这些变量数据的类型有标签数据、序列数据、连续数据。变量的完整列表如下:

    • 年龄。
    • 阶级。
    • 最终重量。
    • 教育程度。
    • 教育年限。
    • 婚姻状况。
    • 职业。
    • 社交。
    • 种族。
    • 性别。
    • 资本收益。
    • 资本损失。
    • 每周工作小时数。
    • 国籍。

    总共有48842行数据,3620行含有缺失数据,45222行具有完整的数据,其中缺失值用?标记。
    有'>50K'和'<=50K'两类标签数据,也就是说它是一个二分类任务。同时这些标签数据分布不平衡,'<=50K'类标签比重更大。
    考虑到标签数据分布不平衡的情况并不严重,并且两个标签同等重要,本教程采用常见的分类准确度或分类误差来反映此数据集上的相关模型性能。

    分析数据集

    成人数据集是一个广泛使用的标准机器学习数据集,用于探索和演示许多一般性的或专门为不平衡分类设计的机器学习算法。

    首先,下载数据集并将其保存在当前工作目录中,命名为“adult-all.csv”.

    接下来让我们考察一下该数据集。文件的前几行如下:

    39,State-gov,77516,Bachelors,13,Never-married,Adm-clerical,Not-in-family,White,Male,2174,0,40,United-States,<=50K
    50,Self-emp-not-inc,83311,Bachelors,13,Married-civ-spouse,Exec-managerial,Husband,White,Male,0,0,13,United-States,<=50K
    38,Private,215646,HS-grad,9,Divorced,Handlers-cleaners,Not-in-family,White,Male,0,0,40,United-States,<=50K
    53,Private,234721,11th,7,Married-civ-spouse,Handlers-cleaners,Husband,Black,Male,0,0,40,United-States,<=50K
    28,Private,338409,Bachelors,13,Married-civ-spouse,Prof-specialty,Wife,Black,Female,0,0,40,Cuba,<=50K
    ...

    我们可以看到,输入变量包含有连续数据、标签数据以及序号数据,对于标签数据需要进行二进制或者独热编码。同时也需要注意到,目标变量是用字符串表示的,而对于二分类问题,需要用0/1进行标签编码,因此对于占比多的多数标签编码为0,而占比较少的少数标签则编码为1。缺失的数据用?表示,通常可以估算这些值,也可以直接从数据集中删除这些行。

    具体的载入数据集方法可使用read_csv()这一Pandas包的内置函数,只需要指定文件名、是否读入标题行以及缺失值的对应符号(本数据为?,缺失值会被处理为NaN数据):

    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    dataframe = read_csv(filename, header=None, na_values='?')

    成功加载数据集后,我们需要移除缺失数据所在的行,并统计数据大小:

    # drop rows with missing
    dataframe = dataframe.dropna()
    # summarize the shape of the dataset
    print(dataframe.shape)

    通过Counter函数我们可以统计数据集分布情况:

    # summarize the class distribution
    target = dataframe.values[:,-1]
    counter = Counter(target)
    for k,v in counter.items():
        per = v / len(target) * 100
        print('Class=%s, Count=%d, Percentage=%.3f%%' % (k, v, per))

    上述函数集合到一起,就实现了数据加载和相关统计工作。完整代码如下:

    # load and summarize the dataset
    from pandas import read_csv
    from collections import Counter
    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    dataframe = read_csv(filename, header=None, na_values='?')
    # drop rows with missing
    dataframe = dataframe.dropna()
    # summarize the shape of the dataset
    print(dataframe.shape)
    # summarize the class distribution
    target = dataframe.values[:,-1]
    counter = Counter(target)
    for k,v in counter.items():
        per = v / len(target) * 100
        print('Class=%s, Count=%d, Percentage=%.3f%%' % (k, v, per))

    运行结果如下:

    (45222, 15)
    Class= <=50K, Count=34014, Percentage=75.216%
    Class= >50K, Count=11208, Percentage=24.784%

    在上述代码中,首先我们加载了数据集,并确认了行和列的数量,即45222行,15列(14个输入变量和一个目标变量)。然后分析了数据分布情况,发现数据分布是不平衡的,大约75%的数据都是(<=50K),而只有大约25%的数据是(>50K)。

    通过创建直方图,我们可以更直观地看到数据分布情况。具体做法如下:
    首先,调用select_dtypes函数选取数值型数据。

    ...
    # select columns with numerical data types
    num_ix = df.select_dtypes(include=['int64', 'float64']).columns
    # select a subset of the dataframe with the chosen columns
    subset = df[num_ix]

    然后通过matplotlib绘图包进行显示。

    # create histograms of numeric input variables
    from pandas import read_csv
    from matplotlib import pyplot
    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    df = read_csv(filename, header=None, na_values='?')
    # drop rows with missing
    df = df.dropna()
    # select columns with numerical data types
    num_ix = df.select_dtypes(include=['int64', 'float64']).columns
    # select a subset of the dataframe with the chosen columns
    subset = df[num_ix]
    # create a histogram plot of each numeric variable
    subset.hist()
    pyplot.show()

    运行上述代码,将为数据集中的六个输入变量分别创建一个直方图。

     

    我们可以看到它们有着不同的分布情况,有些是高斯分布,有些是指数分布或离散分布。同样可以看出,他们的变化范围差异较大。而为了得到较好的算法效果,我们通常需要将数据分布缩放到相同的范围,因此需要进行相应的幂变换。

    基础模型和性能评价

    k-fold交叉验证方法能够较好估计模型的性能。在这里我们将使用k=10的重复分层k-fold交叉验证方法来评估相关模型,这意味着每个折叠将包含约45222/10=4522个数据。而分层表示每一个折叠将包含相同的混合比例(即每个折叠中指标数据都具有75%-25%的分布特征)。重复表示评估过程将被多次执行,以避免偶然结果和更好地捕获所选模型的方差,本教程中,我们将重复三次。这意味着将对单个模型进行10×3=30次拟合和评估,并记录每次运行结果的平均值和标准差。

    上述方法可以通过scikit-learn包里面的RepeatedStratifiedKFold函数实现。
    具体代码如下:

    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores

    通过evaluate_model()函数我们实现了获取加载的数据集和定义的模型,使用重复分层k-fold交叉验证对其进行评估,然后返回一个准确度列表。

    而如何生成X、Y数据呢?我们可以定义一个函数来加载数据集并对目标列进行编码,然后返回所需数据。具体代码如下:

    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix

    通过以上步骤,我们就可以使用这个测试工具评估数据集的相关模型了。

    为了更好地评估若干模型之间的差距,我们可以通过scikit库里面的DummyClassifier类建立一个基准模型。相关代码如下:

    # define the reference model
    model = DummyClassifier(strategy='most_frequent')
    # evaluate the model
    scores = evaluate_model(X, y, model)
    # summarize performance
    print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

    上述函数集合到一起,就实现了一个基准算法对于数据集的预测分类和评价。完整代码如下:

    # test harness and baseline model evaluation for the adult dataset
    from collections import Counter
    from numpy import mean
    from numpy import std
    from numpy import hstack
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.dummy import DummyClassifier
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # summarize the loaded dataset
    print(X.shape, y.shape, Counter(y))
    # define the reference model
    model = DummyClassifier(strategy='most_frequent')
    # evaluate the model
    scores = evaluate_model(X, y, model)
    # summarize performance
    print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

    运行结果如下:

    (45222, 14) (45222,) Counter({0: 34014, 1: 11208})
    Mean Accuracy: 0.752 (0.000)

    通过上述代码,我们首先加载数据并进行预处理。然后通过DummyClassifier()进行分类,并通过RepeatedStratifiedKFold()进行评价。可以看到,基准算法达到了约75.2%的准确度。这一结果指出了相关模型的准确度下限;任何平均准确度高于75.2%的模型都可被视为有效模型,而低于75.2%则通常被认为是无效的。

    模型评价

    在上一节中,我们看到,基准算法的性能良好,但还有很大的优化空间。
    在本节中,我们将使用上一节中所描述的评价方法评估作用于同一数据集的不同算法。
    目的是演示如何系统地解决问题,以及某些为不平衡分类问题设计的算法。

    不同的机器学习算法

    在这里,我们选取一系列非线性算法来进行具体的评价,如:

    • 决策树(CART,Decision Tree)
    • 支持向量机(SVM,Support Vector Machine)
    • 袋装决策树(BAG,Bagged Decision Trees)
    • 随机森林(RF,Random Forest)
    • 爬坡机(GBM,Gradient Boosting Machine)

    首先定义一个列表,依次定义每个模型并将它们添加到列表中,以便于后面将运算的结果进行列表显示。代码如下:

    # define models to test
    def get_models():
        models, names = list(), list()
        # CART
        models.append(DecisionTreeClassifier())
        names.append('CART')
        # SVM
        models.append(SVC(gamma='scale'))
        names.append('SVM')
        # Bagging
        models.append(BaggingClassifier(n_estimators=100))
        names.append('BAG')
        # RF
        models.append(RandomForestClassifier(n_estimators=100))
        names.append('RF')
        # GBM
        models.append(GradientBoostingClassifier(n_estimators=100))
        names.append('GBM')
        return models, names

    针对每一个算法,我们将主要使用默认的模型超参数。对标签变量进行独热编码,对连续型数据变量通过MinMaxScaler进行规范化处理。具体的,建立一个Pipeline,其中第一步使用ColumnTransformer()函数;第二步使用OneHotEncoder()函数;第三步使用MinMaxScaler函数。相关代码如下:

    ...
    # define steps
    steps = [('c',OneHotEncoder(handle_unknown='ignore'),cat_ix), ('n',MinMaxScaler(),num_ix)]
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer(steps)
    # wrap the model i a pipeline
    pipeline = Pipeline(steps=[('t',ct),('m',models[i])])
    # evaluate the model and store results
    scores = evaluate_model(X, y, pipeline)
    # summarize performance
    print('>%s %.3f (%.3f)' % (names[i], mean(scores), std(scores)))

    同时,我们可以通过作图进行直观的比较:

    ...
    # plot the results
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

    上述代码集合到一起,我们就实现了对于若干算法性能的对比。完整代码如下:

    # spot check machine learning algorithms on the adult imbalanced dataset
    from numpy import mean
    from numpy import std
    from pandas import read_csv
    from matplotlib import pyplot
    from sklearn.preprocessing import LabelEncoder
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.pipeline import Pipeline
    from sklearn.compose import ColumnTransformer
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn.ensemble import BaggingClassifier
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores
    
    # define models to test
    def get_models():
        models, names = list(), list()
        # CART
        models.append(DecisionTreeClassifier())
        names.append('CART')
        # SVM
        models.append(SVC(gamma='scale'))
        names.append('SVM')
        # Bagging
        models.append(BaggingClassifier(n_estimators=100))
        names.append('BAG')
        # RF
        models.append(RandomForestClassifier(n_estimators=100))
        names.append('RF')
        # GBM
        models.append(GradientBoostingClassifier(n_estimators=100))
        names.append('GBM')
        return models, names
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # define models
    models, names = get_models()
    results = list()
    # evaluate each model
    for i in range(len(models)):
        # define steps
        steps = [('c',OneHotEncoder(handle_unknown='ignore'),cat_ix), ('n',MinMaxScaler(),num_ix)]
        # one hot encode categorical, normalize numerical
        ct = ColumnTransformer(steps)
        # wrap the model i a pipeline
        pipeline = Pipeline(steps=[('t',ct),('m',models[i])])
        # evaluate the model and store results
        scores = evaluate_model(X, y, pipeline)
        results.append(scores)
        # summarize performance
        print('>%s %.3f (%.3f)' % (names[i], mean(scores), std(scores)))
    # plot the results
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

    运行结果如下:

    >CART 0.812 (0.005)
    >SVM 0.837 (0.005)
    >BAG 0.852 (0.004)
    >RF 0.849 (0.004)
    >GBM 0.863 (0.004)

     

    我们可以看到所选择的所有算法都达到了75.2%以上的分类准确度。其中GBM算法表现最好,分类准确度约为86.3%。这一结果只是略好于基准算法的结果。而图中虽然存在一些异常值(图上的圆圈),但每个算法的结果都高于75%的基线。每个算法的分布看起来也很紧凑,中位数和平均值基本持平,这表明算法在这个数据集上是相当稳定的。这突出表明,重要的不仅仅是模型性能的综合趋势,更应该考虑的是对于少数类别的分类结果准确度(这在少数民族的相关例子中尤为重要)。

    对新输入数据进行预测

    本节中,我们将使用GradientBoostingClassfier分类模型用于新输入数据的预测。拟合这个模型需要定义ColumnTransformer来对标签数据变量进行编码并缩放连续数据变量,并且在拟合模型之前在训练集上构造一个Pipeline来执行这些变换。具体代码如下:

    ...
    # define model to evaluate
    model = GradientBoostingClassifier(n_estimators=100)
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer([('c',OneHotEncoder(),cat_ix), ('n',MinMaxScaler(),num_ix)])
    # scale, then oversample, then fit model
    pipeline = Pipeline(steps=[('t',ct), ('m',model)])

    函数定义完成后,我们就可以调用该函数进行参数拟合了:

    ...
    # fit the model
    pipeline.fit(X, y)

    拟合阶段过后,通过predict()函数进行预测,返回输入数据对应的标签是“<=50K”还是“>50K”:

    ...
    # define a row of data
    row = [...]
    # make prediction
    yhat = pipeline.predict([row])

    通过GradientBoostingClassfier分类模型进行预测的完整代码如下:

    # fit a model and make predictions for the on the adult dataset
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.compose import ColumnTransformer
    from sklearn.ensemble import GradientBoostingClassifier
    from imblearn.pipeline import Pipeline
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # define model to evaluate
    model = GradientBoostingClassifier(n_estimators=100)
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer([('c',OneHotEncoder(),cat_ix), ('n',MinMaxScaler(),num_ix)])
    # scale, then oversample, then fit model
    pipeline = Pipeline(steps=[('t',ct), ('m',model)])
    # fit the model
    pipeline.fit(X, y)
    # evaluate on some <=50K cases (known class 0)
    print('<=50K cases:')
    data = [[24, 'Private', 161198, 'Bachelors', 13, 'Never-married', 'Prof-specialty', 'Not-in-family', 'White', 'Male', 0, 0, 25, 'United-States'],
        [23, 'Private', 214542, 'Some-college', 10, 'Never-married', 'Farming-fishing', 'Own-child', 'White', 'Male', 0, 0, 40, 'United-States'],
        [38, 'Private', 309122, '10th', 6, 'Divorced', 'Machine-op-inspct', 'Not-in-family', 'White', 'Female', 0, 0, 40, 'United-States']]
    for row in data:
        # make prediction
        yhat = pipeline.predict([row])
        # get the label
        label = yhat[0]
        # summarize
        print('>Predicted=%d (expected 0)' % (label))
    # evaluate on some >50K cases (known class 1)
    print('>50K cases:')
    data = [[55, 'Local-gov', 107308, 'Masters', 14, 'Married-civ-spouse', 'Prof-specialty', 'Husband', 'White', 'Male', 0, 0, 40, 'United-States'],
        [53, 'Self-emp-not-inc', 145419, '1st-4th', 2, 'Married-civ-spouse', 'Exec-managerial', 'Husband', 'White', 'Male', 7688, 0, 67, 'Italy'],
        [44, 'Local-gov', 193425, 'Masters', 14, 'Married-civ-spouse', 'Prof-specialty', 'Wife', 'White', 'Female', 4386, 0, 40, 'United-States']]
    for row in data:
        # make prediction
        yhat = pipeline.predict([row])
        # get the label
        label = yhat[0]
        # summarize
        print('>Predicted=%d (expected 1)' % (label))

    运行结果如下:

    <=50K cases:
    >Predicted=0 (expected 0)
    >Predicted=0 (expected 0)
    >Predicted=0 (expected 0)
    >50K cases:
    >Predicted=1 (expected 1)
    >Predicted=1 (expected 1)
    >Predicted=1 (expected 1)

    运行该代码,我们首先实现了模型在训练数据集上的训练,然后针对新的输入数据进行预测。可以看到,预测值和真实值是一致的,说明模型具有很好的预测功能。

     

    展开全文
  • 不平衡数据分类

    千次阅读 2017-08-28 15:19:43
    引言 不管是在学术界还是工业界,不平衡学习已经吸引了越来越的关注,不平衡数据的场景也出现在互联网...顾名思义即我们的数据集样本类别极均衡,以二分类问题为例,假设我们的数据集是$S$,数据集中的多数类为

    引言

    不管是在学术界还是工业界,不平衡学习已经吸引了越来越多的关注,不平衡数据的场景也出现在互联网应用的方方面面,如搜索引擎的点击预测(点击的网页往往占据很小的比例),电子商务领域的商品推荐(推荐的商品被购买的比例很低),信用卡欺诈检测,网络攻击识别等等。

    问题定义

    那么什么是不平衡数据呢?顾名思义即我们的数据集样本类别极不均衡,以二分类问题为例,假设我们的数据集是$S$,数据集中的多数类为$S_maj$,少数类为$S_min$,通常情况下把多数类样本的比例为$100:1$,$1000:1$,甚至是$10000:1$这种情况下为不平衡数据,不平衡数据的学习即需要在如此分布不均匀的数据集中学习到有用的信息。

    为什么不平衡学习

    传统的学习方法以降低总体分类精度为目标,将所有样本一视同仁,同等对待,如下图1所示,造成了分类器在多数类的分类精度较高而在少数类的分类精度很低。机器学习模型都有一个待优化的损失函数,以我们最常用最简单的二元分类器逻辑回归为例,其损失函数如下公式1所示,逻辑回归以优化总体的精度为目标,不同类别的误分类情况产生的误差是相同的,考虑一个$500:1$的数据集,即使把所有样本都预测为多数类其精度也能达到$500/501$之高,很显然这并不是一个很好的学习效果,因此传统的学习算法在不平衡数据集中具有较大的局限性。


    图1 传统学习在不平衡数据下的缺点

                                                                                                         公式1 逻辑回归的交叉熵损失函数

    不平衡学习的方法

    既然传统的学习算法在不平衡数据中具有较大的局限性,那么针对不平衡数据集又有怎样的解决方案呢?

    针对不平衡数据,我们往往从数据和算法两个层面来进行处理:

           (一)数据层面:又可分为过抽样和欠抽样。

                       a)  过抽样指的是增加少数类的样本数(可以直接重复已有数据,也可以按照一定规则合 成少数类数据);

                       b)  欠抽样指的是减少多数类样本的数量,例如,可以将多数类样本分为“噪音样本”,“边界样本”,“安全样本”,我们将“噪音样本”和“边界样本”删除,只保留“安全样本”,这样就减少了多数类样本的数量。

            (二)算法层面

                        a)  代价敏感:可以给每个训练样本加权或者在算法中引入敏感因子

                        b)  集成学习方法:即多个分类器,然后利用投票或者组合得到结果。又可以分为同态集成学习方法(同种分类器组合)和异态集成学习方法(多种分类器组合)

                        c)  单类分类器方法:仅对少数类进行训练,例如运用SVM算法

    采样

    随机采样

    采样算法通过某一种策略改变样本的类别分布,以达到将不平衡分布的样本转化为相对平衡分布的样本的目的,而随机采样是采样算法中最简单也最直观易懂的一种方法。随机采样主要分为两种类型,分别为随机欠采样和随机过采样两种。随机欠采样顾名思义即从多数类$S_maj$中随机选择少量样本$E$再合并原有少数类样本作为新的训练数据集,新数据集为$S_min+E$,随机欠采样有两种类型分别为有放回和无放回两种,无放回欠采样在对多数类某样本被采样后不会再被重复采样,有放回采样则有可能。随机过采样则正好相反,即通过多次有放回随机采样从少数类$S_min$中抽取数据集$E$,采样的数量要大于原有少数类的数量,最终的训练集为$S_maj+E$。

    可以看到随机采样通过改变多数类或少数类样本比例以达到修改样本分布的目的,从而让样本分布较为均衡,但是他们也存在一些问题。对于随机欠采样,由于采样的样本要少于原样本集合,因此会造成一些信息缺失,未被采样的样本往往带有很重要的信息。对于随机过采样,由于需要对少数类样本进行复制因此扩大了数据集,造成模型训练复杂度加大,另一方面也容易造成模型的过拟合问题。针对这些问题提出了几种其它的采样算法。

    SMOTE算法

    SMOTE全称是Synthetic Minority Oversampling Technique即合成少数类过采样技术,它是基于随机过采样算法的一种改进方案,由于随机过采样采取简单复制样本的策略来增加少数类样本,这样容易产生模型过拟合的问题,即使得模型学习到的信息过于特别(Specific)而不够泛化(General),SMOTE算法的基本思想是对少数类样本进行分析并根据少数类样本人工合成新样本添加到数据集中,具体如图2所示,算法流程如下。

    1. 对于少数类中每一个样本$x$,以欧氏距离为标准计算它到少数类样本集$S_min$中所有样本的距离,得到其k近邻。
    2. 根据样本不平衡比例设置一个采样比例以确定采样倍率$N$,对于每一个少数类样本$x$,从其k近邻中随机选择若干个样本,假设选择的近邻为$\hat{x}$。
    3. 对于每一个随机选出的近邻$\hat{x}$,分别与原样本按照如下的公式构建新的样本。



                                                                                                                            图2 SMOTE算法

      SMOTE算法摒弃了随机过采样复制样本的做法,可以防止随机过采样易过拟合的问题,实践证明此方法可以提高分类器的性能。但是由于对每个少数类样本都生成新样本,因此容易发生生成样本重叠(Overlapping)的问题,为了解决SMOTE算法的这一缺点提出一些改进算法,其中的一种是Borderline-SMOTE算法,如图3所示。
      在Borderline-SMOTE中,若少数类样本的每个样本$x_i$求k近邻,记作$S_i-knn$,且$S_i-knn$属于整个样本集合$S$而不再是少数类样本,若满足


      则将样本$x_i$加入DANGER集合,显然DANGER集合代表了接近分类边界的样本,将DANGER当作SMOTE种子样本的输入生成新样本。特别地,当上述条件取右边界,即k近邻中全部样本都是多数类时,此样本不会被选择为种样本生成新样本,此情况下的样本为噪音。

      图3 Borderline-SMOTE算法

    Informed Undersampling

    既然SMOTE可以解决随机过采样容易发生的模型过拟合问题,对应地也有一些采样方法可以解决随机欠采样造成的数据信息丢失问题,答案是Informed undersampling采样技术,informed undersampling采样技术主要有两种方法分别是EasyEnsemble算法和BalanceCascade算法。
    EasyEnsemble算法如下图4所示,此算法类似于随机森林的Bagging方法,它把数据划分为两部分,分别是多数类样本和少数类样本,对于多数类样本$S_maj$,通过n次有放回抽样生成n份子集,少数类样本分别和这n份样本合并训练一个模型,这样可以得到n个模型,最终的模型是这n个模型预测结果的平均值。BalanceCascade算法是一种级联算法,BalanceCascade从多数类$S_maj$中有效地选择N且满足$\midN\mid=\midS_min\mid$,将N和$\S_min$合并为新的数据集进行训练,新训练集对每个多数类样本$x_i$进行预测若预测对则$S_maj=S_maj-x_i$。依次迭代直到满足某一停止条件,最终的模型是多次迭代模型的组合。


                                                                                                                                      图4 EasyEsemble算法

    展开全文
  • 数据集不平衡带来的问题:  在一个分类问题中,如果在所有你想要预测的类别里有一个或者个类别的样本量非常少,那你的数据也许就面临不平衡类别的问题。如: 1.欺诈预测(欺诈的数量远远小于真实交易的数量) ...
  • 数据集类别不平衡问题

    千次阅读 2020-09-15 20:12:32
    考虑样本不平衡的很情况下,学习算法会使分类器放弃负例预测,因为把所有样本都分为正便可获得高达99%的训练分类准确率。 数据集方面进行处理: 欠采样:去处一些分类中多余的样本,使达到正负样本平衡; 过...
  • 样本数据集不平衡处理方式

    千次阅读 2020-10-14 15:44:54
     搜集更数据来使数据达到平衡,但是一般出现样本不平衡问题,就是太可能以一种简单的方法获取到更的样本(在金融领域,可以思考坏用户的定义是否过于严格) 1.2、数据增广: 目前数据增广主要应用于图像...
  • UCI银行营销数据集--数据集不平衡

    千次阅读 2018-12-27 16:45:09
    数据集基本情况 目标: 根据相关的信息预测通过电话推销,用户是否会在银行进行存款。 特征:总共有50个特征。 年龄,工作类型,婚姻状况,受教育背景,信用情况,房贷,个人贷款,联系电话是手机还是固定电话...
  • 不平衡数据集的处理

    千次阅读 2019-09-30 12:22:20
    一、不平衡数据集的定义 所谓的不平衡数据集指的是数据集各个类别的样本量极均衡。以二分类问题为例,假设正类的样本数量远大于负类的样本数量,通常情况下通常情况下把多数类样本的比例接近100:1这种情况下的...
  • 解决不平衡数据集问题

    千次阅读 2019-07-29 16:39:38
    解决不平衡数据集问题 数据不平衡通常反映数据集中类的均匀分布。例如,在信用卡欺诈检测数据集中,大多数信用卡交易都不是欺诈,只有很少的类是欺诈交易。这使得我们在欺诈类和非欺诈类之间的比例约为50:1。 ...
  • 平衡数据集 focal loss 分类

    千次阅读 2019-04-24 10:42:38
    本教程将向您展示如何在给定的高度不平衡数据集的情况下,应用焦点损失函数来训练一个多分类模型。  背景 让我们首先了解类别不平衡数据集的一般的处理方法,然后再学习 focal loss 的解决方式。 ...
  • 1.不平衡数据集的评估指标有哪些? 评估指标1:recall,Precision,F-score,其中F-score是两者的中和,一般认为F-measure越高,分类器的性能越好; Precision就是提交给用户的结果里边,究竟有多少是对的; Recall...
  • 在处理分类问题时,数据集可能会存在类不平衡问题,如在某冰箱厂家生产的10000台冰箱中,有9900台为合格产品,而剩余的100台为合格产品。在这种情境下,即使采用将全部样本分类为正类的分类器也可以得到99%的准确...
  • 而在我们采集自己的数据集训练时,获得的样本数量是不平衡的,某一类样本,另一些样本少,甚至没有。比如某一疾病的医学影像,大部分都是健康的,只有小部分患病。 二、错分成本不平衡 同样,在学术中...
  • 数据集在这里下载:数据集下载.(信用卡欺诈比赛). import numpy as np import pandas as pd from sklearn.preprocessing import RobustScaler from sklearn.model_selection import train_test_...
  • 多分类学习、类别不平衡

    千次阅读 2017-10-27 21:11:09
    多分类学习、类别不平衡
  • Class Confidence Proportion不平衡数据集的决策树算法CCP算法是一种基于C4.5算法改进、用于处理不平衡数据集的决策树划分算法。 其基本思想是提出一种新的置信度公式,从而使关注点集中于实例预测正确的比例,从而...
  • 最近在做的项目的数据集里的数据分布非常不平衡,虽然是简单的二分类任务,但是两类数据的比例相差有两个数量级。因此查了一些解决数据分布不平衡的方法,在这里先总结一下,后面会单独挑出一些方法实现,并针对相应...
  • 数据集类别不平衡通常发生在分类问题上,例如有两个类别(A,B)的数据集,A有80个,而B有20个,那么这个数据集不平衡的。大多数数据集每一个类别通常不是完全的平衡,小的不平衡不会有太大的问题。但是当样本分布...
  • 本文主要讲述KNN最近邻分类算法、简单实现分析平衡数据集,希望这篇文章对大家有所帮助,同时提供些思路。内容包括: 1.KNN算法基础原理知识 2.最近邻分类算法分析预测坐标类型 3.Pandas读取TXT数据集 4.KNN...
  • 不平衡数据分类算法

    千次阅读 2017-07-26 12:55:10
    不平衡数据分类算法介绍与比较 标签: 数据挖掘不平衡数据机器学习 2016-08-28 21:41 6021人阅读 评论(3) 收藏 举报  分类数据挖掘(7)  目录(?)[+] 介绍 在数据...
  • 不平衡数据分类方法

    千次阅读 2020-05-06 11:52:18
    文章目录概述定义传统分类器对于不平衡数据适用性可应用领域分类方法总框架数据层面样本采样技术随机采样技术人工采样技术经典过采样方法经典欠采样方法其他方法:特征层面Filter过滤式Wrapped封装式Embedded...
  • 不平衡数据分类算法介绍与比较

    万次阅读 多人点赞 2016-08-28 21:41:28
    数据挖掘中,经常会存在不平衡数据分类问题,比如在异常监控预测中,由于异常就大多数情况下都不会出现,因此想要达到良好的识别效果普通的分类算法还远远不够,这里介绍几种处理不平衡数据的常用方法及对比。
  • 数据不平衡分类问题

    千次阅读 2019-07-01 19:29:27
    数据层面上,以某种方法平衡训练: 过度采样少数分类。 对多数分类进行抽样。 合成新的少数分类。 抛弃一定少数分类,转而采用异常检测框架。 在算法层面上: 调整样本权重(调整错误分类的损失)。...
  • 这是一个不平衡数据集,因为类别1比类别2的样本总数为4:1.仅仅是二分类问题有类别不平衡问题,分类问题也存在类别不平衡的问题。不平衡问题很常见大部分的分类数据集中各类别的样本总数不会绝对一样,但是稍稍...
  • 不平衡数据集: 在分类等问题中,正负样本,或者各个类别的样本数目一致。 :在人脸检测中,比如训练库有10万张人脸图像,其中9万没有包含人脸,1万包含人脸,这个数据集就是典型的不平衡数据集。 直观的影响...
  • 机器学习中的数据不平衡解决方案大全

    万次阅读 多人点赞 2017-06-09 19:37:12
    在机器学习任务中,我们经常会遇到这种困扰:数据不平衡问题。...绝大多数常见的机器学习算法对于不平衡数据集能很好地工作。 本文介绍几种有效的解决数据不平衡情况下有效训练有监督算法的思路:1、重新采样训练集
  • 类别不平衡(class-imbalance),是指分类任务中不同类别的训练样例数目差别很大的情况(例如,训练正类样例10个,反类样例90个),本文假设正类样例较少,反类样例较。 现有解决方案大体分为三类,如下文所示。...
  • 不平衡数据分类评价指标总结

    千次阅读 2018-09-26 19:46:53
    下图是一个二分类问题的混淆矩阵: TP:正确肯定——实际是正例,识别为正例 FN:错误否定(漏报)——实际是正例,却识别成了负例 FP:错误肯定(误报)——实际是负例,却识别成了正例 TN:正...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,699
精华内容 20,679
关键字:

多分类数据集不平衡