精华内容
下载资源
问答
  • imblearn包,主要解决样本不均衡问题,开源项目,可从官网下载。目前已更名为imbalanced-learn。但出于维护历史版本代码仍需使用旧版。依赖sklearn等
  • imblearn算法详解及实例

    千次阅读 2019-09-03 23:21:11
    过采样(Over-sampling) 1、RandomOverSampler ...from imblearn.over_sampling import RandomOverSampler ros = RandomOverSampler(sampling_strategy={0: 900,2:200,1:300 },random_state=0) X_resa...

    参考原文:
    https://blog.csdn.net/qq_31813549/article/details/79964973
    https://www.cnblogs.com/massquantity/p/9382710.html
    官方文档:
    https://imbalanced-learn.org/en/stable/generated/imblearn.over_sampling.RandomOverSampler.html

    过采样

    参考文献:https://www.cnblogs.com/massquantity/p/9382710.html
    1、RandomOverSampler
    原理:从样本少的类别中随机抽样,再将抽样得来的样本添加到数据集中。
    缺点:重复采样往往会导致严重的过拟合
    主流过采样方法是通过某种方式人工合成一些少数类样本,从而达到类别平衡的目的,而这其中的鼻祖就是SMOTE。

    from imblearn.over_sampling import RandomOverSampler
    ros = RandomOverSampler(sampling_strategy={0: 700,1:200,2:150 },random_state=0)
    X_resampled, y_resampled = ros.fit_sample(X, y)
    print(Counter(y_resampled))
    

    2、SMOTE
    原理:在少数类样本之间进行插值来产生额外的样本。对于少数类样本a, 随机选择一个最近邻的样本b, 从a与b的连线上随机选取一个点c作为新的少数类样本;
    具体地,对于一个少数类样本xi使用K近邻法(k值需要提前指定),求出离xi距离最近的k个少数类样本,其中距离定义为样本之间n维特征空间的欧氏距离。然后从k个近邻点中随机选取一个,使用下列公式生成新样本:
    在这里插入图片描述在这里插入图片描述

    from imblearn.over_sampling import SMOTE
    smo = SMOTE(sampling_strategy={0: 700,1:200,2:150 },random_state=42)
    X_smo, y_smo = smo.fit_sample(X, y)
    print(Counter(y_smo))
    

    SMOTE会随机选取少数类样本用以合成新样本,而不考虑周边样本的情况,这样容易带来两个问题

    1)如果选取的少数类样本周围也都是少数类样本,则新合成的样本不会提供太多有用信息。
    2)如果选取的少数类样本周围都是多数类样本,这类的样本可能是噪音,则新合成的样本会与周围的多数类样本产生大部分重叠,致使分类困难。
    总的来说我们希望新合成的少数类样本能处于两个类别的边界附近,这样往往能提供足够的信息用以分类。而这就是下面的 Border-line SMOTE 算法要做的事情。
    3、BorderlineSMOTE
    这个算法会先将所有的少数类样本分成三类,如下图所示:
    “noise” : 所有的k近邻个样本都属于多数类
    “danger” : 超过一半的k近邻样本属于多数类
    “safe”: 超过一半的k近邻样本属于少数类
    在这里插入图片描述
    Border-line SMOTE算法只会从处于”danger“状态的样本中随机选择,然后用SMOTE算法产生新的样本。处于”danger“状态的样本代表靠近”边界“附近的少数类样本,而处于边界附近的样本往往更容易被误分类。因而 Border-line SMOTE 只对那些靠近”边界“的少数类样本进行人工合成样本,而 SMOTE 则对所有少数类样本一视同仁。

    Border-line SMOTE 分为两种: Borderline-1 SMOTE 和 Borderline-2 SMOTE。 Borderline-1 SMOTE 在合成样本时式中的x^
    是一个少数类样本,而 Borderline-2 SMOTE 中的x^则是k近邻中的任意一个样本。

    from imblearn.over_sampling import BorderlineSMOTE
    smo = BorderlineSMOTE(kind='borderline-1',sampling_strategy={0: 700,1:200,2:150 },random_state=42) #kind='borderline-2'
    X_smo, y_smo = smo.fit_sample(X, y)
    print(Counter(y_smo))
    

    4、ADASYN
    原理:采用某种机制自动决定每个少数类样本需要产生多少合成样本,而不是像SMOTE那样对每个少数类样本合成同数量的样本。先确定少数样本需要合成的样本数量(与少数样本周围的多数类样本数呈正相关),然后利用SMOTE合成样本。
    缺点:ADASYN的缺点是易受离群点的影响,如果一个少数类样本的K近邻都是多数类样本,则其权重会变得相当大,进而会在其周围生成较多的样本。

    from imblearn.over_sampling import ADASYN
    ana = ADASYN(sampling_strategy={0: 800,2:300,1:400 },random_state=0)
    X_ana, y_ana = ana.fit_sample(X, y)
    

    用 SMOTE 合成的样本分布比较平均,而Border-line SMOTE合成的样本则集中在类别边界处。ADASYN的特性是一个少数类样本周围多数类样本越多,则算法会为其生成越多的样本,从图中也可以看到生成的样本大都来自于原来与多数类比较靠近的那些少数类样本。

    5、KMeansSMOTE
    原理:在使用SMOTE进行过采样之前应用KMeans聚类。
    KMeansSMOTE包括三个步骤:聚类、过滤和过采样。在聚类步骤中,使用k均值聚类为k个组。过滤选择用于过采样的簇,保留具有高比例的少数类样本的簇。然后,它分配合成样本的数量,将更多样本分配给少数样本稀疏分布的群集。最后,过采样步骤,在每个选定的簇中应用SMOTE以实现少数和多数实例的目标比率。

    from imblearn.over_sampling import KMeansSMOTE
    kms = KMeansSMOTE(sampling_strategy={0: 800,2:300,1:400 },random_state=42)
    X_kms, y_kms = kms.fit_sample(X, y)
    print(Counter(y_kms))
    

    6、SMOTENC
    可处理分类特征的SMOTE

    from imblearn.over_sampling import SMOTENC
    sm = SMOTENC(random_state=42, categorical_features=[18, 19])
    

    7、SVMSMOTE
    使用支持向量机分类器产生支持向量然后再生成新的少数类样本,然后使用SMOTE合成样本

    from imblearn.over_sampling import SVMSMOTE
    svmm = SVMSMOTE(sampling_strategy={0: 800,2:300,1:400 },random_state=42)
    X_svmm, y_svmm = svmm.fit_sample(X, y)
    print(Counter(y_kms))
    

    欠采样(under_sampling)

    1、ClusterCentroids
    每一个类别的样本都会用K-Means算法的中心点来进行合成, 而不是随机从原始样本进行抽取.

    #下采样ClusterCentroids接口
    from imblearn.under_sampling import ClusterCentroids
    cc = ClusterCentroids(sampling_strategy={0: 50,2:100,1:100 },random_state=0)
    X_resampled, y_resampled = cc.fit_sample(X, y)
    print(sorted(Counter(y_resampled).items()))
    

    2、RandomUnderSampler
    随机选取数据的子集.

    from imblearn.under_sampling import RandomUnderSampler
    cc = RandomUnderSampler(sampling_strategy={0: 50,2:100,1:100 },random_state=0)
    X_resampled, y_resampled = cc.fit_sample(X, y)
    print(sorted(Counter(y_resampled).items()))
    

    使用replacement 为False(默认值)时为不重复采样
    3、NearMiss
    添加了一些启发式(heuristic)的规则来选择样本, 通过设定version参数来实现三种启发式的规则.

    假设正样本是需要下采样的(多数类样本), 负样本是少数类的样本.则:
    NearMiss-1: 选择离N个近邻的负样本的平均距离最小的正样本;
    NearMiss-2: 选择离N个负样本最远的平均距离最小的正样本;
    NearMiss-3: 是一个两段式的算法. 首先, 对于每一个负样本, 保留它们的M个近邻样本; 接着, 那些到N个近邻样本平均距离最大的正样本将被选择.

    from imblearn.under_sampling import NearMiss
    nm1 = NearMiss(sampling_strategy={0: 50,2:100,1:100 },random_state=0, version=1)
    X_resampled_nm1, y_resampled = nm1.fit_sample(X, y)
    print(sorted(Counter(y_resampled).items()))
    

    4、TomekLinks

    TomekLinks : 样本x与样本y来自于不同的类别, 满足以下条件, 它们之间被称之为TomekLinks:不存在另外一个样本z, 使得d(x,z) < d(x,y) 或者 d(y,z) < d(x,y)成立. 其中d(.)表示两个样本之间的距离, 也就是说两个样本之间互为近邻关系. 这个时候, 样本x或样本y很有可能是噪声数据, 或者两个样本在边界的位置附近.

    TomekLinks函数中的auto参数控制Tomek’s links中的哪些样本被剔除. 默认的ratio=‘auto’ 移除多数类的样本, 当ratio='all’时, 两个样本均被移除.

    from collections import Counter
    from imblearn.under_sampling import TomekLinks 
    tl = TomekLinks()
    X_res, y_res = tl.fit_resample(X, y)
    

    5、EditedNearestNeighbours

    应用最近邻算法来编辑(edit)数据集, 找出那些与邻居不太友好的样本然后移除. 对于每一个要进行下采样的样本, 那些不满足一些准则的样本将会被移除; 他们的绝大多数(kind_sel=‘mode’)或者全部(kind_sel=‘all’)的近邻样本都属于同一个类, 这些样本会被保留在数据集中.

    #n_neighbors :int或object,optional(default = 3)
    from collections import Counter
    from sklearn.datasets import make_classification
    from imblearn.under_sampling import EditedNearestNeighbours 
    X, y = make_classification(n_classes=2, class_sep=2,
    weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
    n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
    print('Original dataset shape %s' % Counter(y))
    
    enn = EditedNearestNeighbours()
    X_res, y_res = enn.fit_resample(X, y)
    print('Resampled dataset shape %s' % Counter(y_res))
    

    6、RepeatedEditedNearestNeighbours
    重复EditedNearestNeighbours多次
    max_iter :int,optional(默认值= 100)#迭代次数

    from collections import Counter
    from sklearn.datasets import make_classification
    from imblearn.under_sampling import RepeatedEditedNearestNeighbours # doctest : +NORMALIZE_WHITESPACE
    X, y = make_classification(n_classes=2, class_sep=2,
    weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
    n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
    print('Original dataset shape %s' % Counter(y))
    
    renn = RepeatedEditedNearestNeighbours()
    X_res, y_res = renn.fit_resample(X, y)
    print('Resampled dataset shape %s' % Counter(y_res))
    

    7、ALLKNN
    在进行每次迭代的时候, 最近邻的数量都在增加.

    from collections import Counter
    from sklearn.datasets import make_classification
    from imblearn.under_sampling import AllKNN 
    X, y = make_classification(n_classes=2, class_sep=2,
    weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
    n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
    print('Original dataset shape %s' % Counter(y))
    
    allknn = AllKNN()
    X_res, y_res = allknn.fit_resample(X, y)
    print('Resampled dataset shape %s' % Counter(y_res))
    

    8、CondensedNearestNeighbour
    使用1近邻的方法来进行迭代, 来判断一个样本是应该保留还是剔除, 具体的实现步骤如下:

    1)集合C: 所有的少数类样本;
    2)选择一个多数类样本(需要下采样)加入集合C, 其他的这类样本放入集合S;
    3)使用集合S训练一个1-NN的分类器, 对集合S中的样本进行分类;
    4)将集合S中错分的样本加入集合C;
    5)重复上述过程, 直到没有样本再加入到集合C.

    CondensedNearestNeighbour方法对噪音数据是很敏感的, 也容易加入噪音数据到集合C中.

    from collections import Counter 
    from sklearn.datasets import fetch_mldata 
    from imblearn.under_sampling import CondensedNearestNeighbour 
    pima = fetch_mldata('diabetes_scale') 
    X, y = pima['data'], pima['target'] 
    print('Original dataset shape %s' % Counter(y)) 
    
    cnn = CondensedNearestNeighbour(random_state=42) 
    X_res, y_res = cnn.fit_resample(X, y) 
    print('Resampled dataset shape %s' % Counter(y_res)) 
    

    9、OneSidedSelection
    在CondensedNearestNeighbour的基础上使用 TomekLinks 方法来剔除噪声数据(多数类样本).

    from collections import Counter
    from sklearn.datasets import make_classification
    from imblearn.under_sampling import     OneSidedSelection 
    X, y = make_classification(n_classes=2, class_sep=2,
    weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
    n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
    print('Original dataset shape %s' % Counter(y))
    
    oss = OneSidedSelection(random_state=42)
    X_res, y_res = oss.fit_resample(X, y)
    print('Resampled dataset shape %s' % Counter(y_res))
    

    9、NeighbourhoodCleaningRule
    主要关注如何清洗数据而不是筛选(considering)他们. 因此, 该算法将使用EditedNearestNeighbours和 3-NN分类器结果拒绝的样本之间的并集.

    from collections import Counter
    from sklearn.datasets import make_classification
    from imblearn.under_sampling import NeighbourhoodCleaningRule 
    X, y = make_classification(n_classes=2, class_sep=2,
    weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
    n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
    print('Original dataset shape %s' % Counter(y))
    
    ncr = NeighbourhoodCleaningRule()
    X_res, y_res = ncr.fit_resample(X, y)
    print('Resampled dataset shape %s' % Counter(y_res))
    

    10、InstanceHardnessThreshold
    在数据上运用一种分类器, 然后将概率低于阈值的样本剔除掉.
    在这里插入图片描述

    from sklearn.linear_model import LogisticRegression
    from imblearn.under_sampling import InstanceHardnessThreshold
    iht = InstanceHardnessThreshold(random_state=0,
                                    estimator=LogisticRegression())
    X_resampled, y_resampled = iht.fit_sample(X, y)
    print(sorted(Counter(y_resampled).items()))
    

    三、过采样与欠采样结合(combine)

    SMOTE算法的缺点是生成的少数类样本容易与周围的多数类样本产生重叠难以分类,而数据清洗技术恰好可以处理掉重叠样本,所以可以将二者结合起来形成一个pipeline,先过采样再进行数据清洗。主要的方法是 SMOTE + ENN 和 SMOTE + Tomek ,其中 SMOTE + ENN 通常能清除更多的重叠样本.

    1、SMOTEENN

    from imblearn.combine import SMOTEENN
    smote_enn = SMOTEENN(random_state=0)
    X_resampled, y_resampled = smote_enn.fit_sample(X, y)
    
    print(sorted(Counter(y_resampled).items()))
    

    2、 SMOTETomek

    from imblearn.combine import SMOTETomek
    smote_tomek = SMOTETomek(sampling_strategy={0: 700,1:300,2:200 },random_state=0)
    X_resampled, y_resampled = smote_tomek.fit_sample(X, y)
    print(sorted(Counter(y_resampled).items()))
    

    四、ensemble

    在每次生成训练集时使用所有分类中的小样本量,同时从分类中的大样本量中随机抽取数据来与小样本量合并构成训练集,这样反复多次会得到很多训练集和训练模型。最后在应用时,使用组合方法(例如投票、加权投票等)产生分类预测结果。

    例如,在数据集中的正、负例的样本分别为100和10000条,比例为1:100。此时可以将负例样本(类别中的大量样本集)随机分为100份(当然也可以分更多),每份100条数据;然后每次形成训练集时使用所有的正样本(100条)和随机抽取的负样本(100条)形成新的数据集。如此反复可以得到100个训练集和对应的训练模型。
    一个不均衡的数据集能够通过多个均衡的子集来实现均衡, imblearn.ensemble模块能实现上述功能.

    1、EasyEnsemble (可控制数量)
    从多数类样本中随机抽样成子集,该子集的数量等于少数类样本的数量。接着将该子集与少数类样本结合起来训练一个模型,迭代n次。这样虽然每个子集的样本少于总体样本,但集成后总信息量并不减少。

    from imblearn.ensemble import EasyEnsemble
    ee = EasyEnsemble(random_state=0, n_subsets=10)
    X_resampled, y_resampled = ee.fit_sample(X, y)
    print(X_resampled.shape)
    print(y_resampled.shape)
    print(sorted(Counter(y_resampled[0]).items()))
    

    有两个很重要的参数:
    (i) n_subsets 控制的是子集的个数
    (ii) replacement 决定是有放回还是无放回的随机采样.

    2、BalanceCascade
    在第n轮训练中,将从多数类样本中抽样得来的子集与少数类样本结合起来训练一个基学习器H,训练完后多数类中能被H正确分类的样本会被剔除。在接下来的第n+1轮中,从被剔除后的多数类样本中产生子集用于与少数类样本结合起来训练。
    同样, n_max_subset 参数控制子集的个数, 以及可以通过设置bootstrap=True来使用bootstraping(自助法).

    from imblearn.ensemble import BalanceCascade
    from sklearn.linear_model import LogisticRegression
    bc = BalanceCascade(sampling_strategy={0: 500,1:199,2:89 },random_state=0,
                        estimator=LogisticRegression(random_state=0),
                        n_max_subset=4)
    X_resampled, y_resampled = bc.fit_sample(X, y)
    print(X_resampled.shape)
    print(sorted(Counter(y_resampled[0]).items()))
    
    展开全文
  • imblearn 安装

    千次阅读 2020-10-08 21:28:35
    imblearn 安装 官网安装教程 踩坑经过 1.有些库版本达不到要求:imblearn需要依赖某些Python模块(下面是最新版0.7.0的依赖要求 python (>=3.6) numpy (>=1.13.3) scipy (>=0.19.1) scikit-learn (>...

    imblearn 安装

    踩坑经过

    • 1.有些库版本达不到要求:imblearn需要依赖某些Python模块(下面是最新版0.7.0的依赖要求
      • python (>=3.6)
      • numpy (>=1.13.3)
      • scipy (>=0.19.1)
      • scikit-learn (>=0.23)
      • keras 2 (optional)
      • tensorflow (optional)
    • 2.第一次安装成功的imblearn(0.3.2)库没有SMOTENC方法,花了很久的时间才发现imblearn要到0.4.0以上的版本才有这个方法
    • 3.更新imblearn版本的时候报未安装最新的scikit-learn库的错误,但是我却始终更新不到最新版,后来发现是Python版本为3.5,最新版需要是Python3.6以上
      • 解决方案:imblearn可以不更新的最新的0.7.0,命令如下:
      • pip install imbalanced-learn==0.6.2
    展开全文
  • Imblearn package study 准备知识 1 Compressed Sparse RowsCSR 压缩稀疏的行 过采样Over-sampling 1 实用性的例子 11 朴素随机过采样 12 从随机过采样到SMOTE与ADASYN 13 SMOTE的变体 14 数学公式...
    
    

     

    Imblearn package study

    1. 准备知识

    Sparse input

    For sparse input the data is converted to the Compressed Sparse Rows representation (see scipy.sparse.csr_matrix) before being fed to the sampler. To avoid unnecessary memory copies, it is recommended to choose the CSR representation upstream.

    1.1 Compressed Sparse Rows(CSR) 压缩稀疏的行

    稀疏矩阵中存在许多0元素, 按矩阵A进行存储会占用很大的空间(内存).

    CSR方法采取按行压缩的办法, 将原始的矩阵用三个数组进行表示:

    data = np.array([1, 2, 3, 4, 5, 6])
    indices = np.array([0, 2, 2, 0, 1, 2])
    indptr = np.array([0, 2, 3, 6])
    • 1
    • 2
    • 3
    • 1
    • 2
    • 3

    data数组: 存储着矩阵A中所有的非零元素;

    indices数组: data数组中的元素在矩阵A中的列索引

    indptr数组: 存储着矩阵A中每行第一个非零元素在data数组中的索引.

    from scipy import sparse
    mtx = sparse.csr_matrix((data,indices,indptr),shape=(3,3))
    mtx.todense()
    
    Out[27]: 
    matrix([[1, 0, 2],
            [0, 0, 3],
            [4, 5, 6]])
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    为什么会有针对不平衡数据的研究? 当我们的样本数据中, 正负样本的数据占比极其不均衡的时候, 模型的效果就会偏向于多数类的结果. 具体的可参照官网利用支持向量机进行可视化不同正负样本比例情况下的模型分类结果.

    2. 过采样(Over-sampling)

    2.1 实用性的例子

    2.1.1 朴素随机过采样

    针对不平衡数据, 最简单的一种方法就是生成少数类的样本, 这其中最基本的一种方法就是: 从少数类的样本中进行随机采样来增加新的样本, RandomOverSampler 函数就能实现上述的功能.

    from sklearn.datasets import make_classification
    from collections import Counter
    X, y = make_classification(n_samples=5000, n_features=2, n_informative=2,
                               n_redundant=0, n_repeated=0, n_classes=3,
                               n_clusters_per_class=1,
                               weights=[0.01, 0.05, 0.94],
                               class_sep=0.8, random_state=0)
    Counter(y)
    Out[10]: Counter({0: 64, 1: 262, 2: 4674})
    
    from imblearn.over_sampling import RandomOverSampler
    
    ros = RandomOverSampler(random_state=0)
    X_resampled, y_resampled = ros.fit_sample(X, y)
    
    
    sorted(Counter(y_resampled).items())
    Out[13]:
    [(0, 4674), (1, 4674), (2, 4674)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    以上就是通过简单的随机采样少数类的样本, 使得每类样本的比例为1:1:1.

    2.1.2 从随机过采样到SMOTEADASYN

    相对于采样随机的方法进行过采样, 还有两种比较流行的采样少数类的方法: (i) Synthetic Minority Oversampling Technique (SMOTE); (ii) Adaptive Synthetic (ADASYN) .

    SMOTE: 对于少数类样本a, 随机选择一个最近邻的样本b, 然后从a与b的连线上随机选取一个点c作为新的少数类样本;

    ADASYN: 关注的是在那些基于K最近邻分类器被错误分类的原始样本附近生成新的少数类样本

    from imblearn.over_sampling import SMOTE, ADASYN
    
    X_resampled_smote, y_resampled_smote = SMOTE().fit_sample(X, y)
    
    sorted(Counter(y_resampled_smote).items())
    Out[29]:
    [(0, 4674), (1, 4674), (2, 4674)]
    
    X_resampled_adasyn, y_resampled_adasyn = ADASYN().fit_sample(X, y)
    
    sorted(Counter(y_resampled_adasyn).items())
    Out[30]:
    [(0, 4674), (1, 4674), (2, 4674)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    2.1.3 SMOTE的变体

    相对于基本的SMOTE算法, 关注的是所有的少数类样本, 这些情况可能会导致产生次优的决策函数, 因此SMOTE就产生了一些变体: 这些方法关注在最优化决策函数边界的一些少数类样本, 然后在最近邻类的相反方向生成样本.

    SMOTE函数中的kind参数控制了选择哪种变体, (i) borderline1, (ii) borderline2, (iii) svm:

    from imblearn.over_sampling import SMOTE, ADASYN
    X_resampled, y_resampled = SMOTE(kind='borderline1').fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[31]:
    [(0, 4674), (1, 4674), (2, 4674)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.1.4 数学公式

    SMOTE算法与ADASYN都是基于同样的算法来合成新的少数类样本: 对于少数类样本a, 从它的最近邻中选择一个样本b, 然后在两点的连线上随机生成一个新的少数类样本, 不同的是对于少数类样本的选择.

    原始的SMOTE: kind='regular' , 随机选取少数类的样本.

    The borderline SMOTE: kind='borderline1' or kind='borderline2'

    此时, 少数类的样本分为三类: (i) 噪音样本(noise), 该少数类的所有最近邻样本都来自于不同于样本a的其他类别; (ii) 危险样本(in danger), 至少一半的最近邻样本来自于同一类(不同于a的类别); (iii) 安全样本(safe), 所有的最近邻样本都来自于同一个类.

    这两种类型的SMOTE使用的是危险样本来生成新的样本数据, 对于 Borderline-1 SMOTE, 最近邻中的随机样本b与该少数类样本a来自于不同的类; 不同的是, 对于 Borderline-2 SMOTE , 随机样本b可以是属于任何一个类的样本;

    SVM SMOTE: kind='svm', 使用支持向量机分类器产生支持向量然后再生成新的少数类样本.

    3. 下采样(Under-sampling)

    3.1 原型生成(prototype generation)

    给定数据集S, 原型生成算法将生成一个子集S’, 其中|S’| < |S|, 但是子集并非来自于原始数据集. 意思就是说: 原型生成方法将减少数据集的样本数量, 剩下的样本是由原始数据集生成的, 而不是直接来源于原始数据集.

    ClusterCentroids函数实现了上述功能: 每一个类别的样本都会用K-Means算法的中心点来进行合成, 而不是随机从原始样本进行抽取.

    from imblearn.under_sampling import ClusterCentroids
    
    cc = ClusterCentroids(random_state=0)
    X_resampled, y_resampled = cc.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[32]:
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    ClusterCentroids函数提供了一种很高效的方法来减少样本的数量, 但需要注意的是, 该方法要求原始数据集最好能聚类成簇. 此外, 中心点的数量应该设置好, 这样下采样的簇能很好地代表原始数据.

    3.2 原型选择(prototype selection)

    与原型生成不同的是, 原型选择算法是直接从原始数据集中进行抽取. 抽取的方法大概可以分为两类: (i) 可控的下采样技术(the controlled under-sampling techniques) ; (ii) the cleaning under-sampling techniques(不好翻译, 就放原文, 清洗的下采样技术?). 第一类的方法可以由用户指定下采样抽取的子集中样本的数量; 第二类方法则不接受这种用户的干预.

    3.2.1 Controlled under-sampling techniques

    RandomUnderSampler函数是一种快速并十分简单的方式来平衡各个类别的数据: 随机选取数据的子集.

    from imblearn.under_sampling import RandomUnderSampler
    rus = RandomUnderSampler(random_state=0)
    X_resampled, y_resampled = rus.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[33]:
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    通过设置RandomUnderSampler中的replacement=True参数, 可以实现自助法(boostrap)抽样.

    import numpy as np
    
    np.vstack({tuple(row) for row in X_resampled}).shape
    Out[34]:
    (192L, 2L)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    很明显, 使用默认参数的时候, 采用的是不重复采样;

    from imblearn.under_sampling import RandomUnderSampler
    rus = RandomUnderSampler(random_state=0, replacement=True)
    X_resampled, y_resampled = rus.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[33]:
    [(0, 64), (1, 64), (2, 64)]
    
    np.vstack({tuple(row) for row in X_resampled}).shape
    Out[34]:
    (181L, 2L)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    NearMiss函数则添加了一些启发式(heuristic)的规则来选择样本, 通过设定version参数来实现三种启发式的规则.

    from imblearn.under_sampling import NearMiss
    nm1 = NearMiss(random_state=0, version=1)
    X_resampled_nm1, y_resampled = nm1.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[35]:
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    下面通过一个例子来说明这三个启发式的选择样本的规则, 首先我们假设正样本是需要下采样的(多数类样本), 负样本是少数类的样本.

    NearMiss-1: 选择离N个近邻的负样本的平均距离最小的正样本;

    NearMiss-2: 选择离N个负样本最远的平均距离最小的正样本;

    NearMiss-3: 是一个两段式的算法. 首先, 对于每一个负样本, 保留它们的M个近邻样本; 接着, 那些到N个近邻样本平均距离最大的正样本将被选择.

    3.2.2 Cleaning under-sampling techniques

    3.2.2.1 Tomek’s links

    TomekLinks : 样本x与样本y来自于不同的类别, 满足以下条件, 它们之间被称之为TomekLinks; 不存在另外一个样本z, 使得d(x,z) < d(x,y) 或者 d(y,z) < d(x,y)成立. 其中d(.)表示两个样本之间的距离, 也就是说两个样本之间互为近邻关系. 这个时候, 样本x或样本y很有可能是噪声数据, 或者两个样本在边界的位置附近.

    TomekLinks函数中的auto参数控制Tomek’s links中的哪些样本被剔除. 默认的ratio='auto' 移除多数类的样本, 当ratio='all'时, 两个样本均被移除.

    3.2.2.2 Edited data set using nearest neighbours

    EditedNearestNeighbours这种方法应用最近邻算法来编辑(edit)数据集, 找出那些与邻居不太友好的样本然后移除. 对于每一个要进行下采样的样本, 那些不满足一些准则的样本将会被移除; 他们的绝大多数(kind_sel='mode')或者全部(kind_sel='all')的近邻样本都属于同一个类, 这些样本会被保留在数据集中.

    print sorted(Counter(y).items())
    
    from imblearn.under_sampling import EditedNearestNeighbours
    enn = EditedNearestNeighbours(random_state=0)
    X_resampled, y_resampled = enn.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    
    Out[36]:
    [(0, 64), (1, 262), (2, 4674)]
    [(0, 64), (1, 213), (2, 4568)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在此基础上, 延伸出了RepeatedEditedNearestNeighbours算法, 重复基础的EditedNearestNeighbours算法多次.

    from imblearn.under_sampling import RepeatedEditedNearestNeighbours
    renn = RepeatedEditedNearestNeighbours(random_state=0)
    X_resampled, y_resampled = renn.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[37]:
    [(0, 64), (1, 208), (2, 4551)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    RepeatedEditedNearestNeighbours算法不同的是, ALLKNN算法在进行每次迭代的时候, 最近邻的数量都在增加.

    from imblearn.under_sampling import AllKNN
    allknn = AllKNN(random_state=0)
    X_resampled, y_resampled = allknn.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[38]:
    [(0, 64), (1, 220), (2, 4601)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.2.2.3 Condensed nearest neighbors and derived algorithms

    CondensedNearestNeighbour 使用1近邻的方法来进行迭代, 来判断一个样本是应该保留还是剔除, 具体的实现步骤如下:

    1. 集合C: 所有的少数类样本;
    2. 选择一个多数类样本(需要下采样)加入集合C, 其他的这类样本放入集合S;
    3. 使用集合S训练一个1-NN的分类器, 对集合S中的样本进行分类;
    4. 将集合S中错分的样本加入集合C;
    5. 重复上述过程, 直到没有样本再加入到集合C.
    from imblearn.under_sampling import CondensedNearestNeighbour
    cnn = CondensedNearestNeighbour(random_state=0)
    X_resampled, y_resampled = cnn.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[39]:
    [(0, 64), (1, 24), (2, 115)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    显然, CondensedNearestNeighbour方法对噪音数据是很敏感的, 也容易加入噪音数据到集合C中.

    因此, OneSidedSelection 函数使用 TomekLinks 方法来剔除噪声数据(多数类样本).

    from imblearn.under_sampling import OneSidedSelection
    oss = OneSidedSelection(random_state=0)
    X_resampled, y_resampled = oss.fit_sample(X, y)
    
    print(sorted(Counter(y_resampled).items()))
    Out[39]:
    [(0, 64), (1, 174), (2, 4403)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    NeighbourhoodCleaningRule 算法主要关注如何清洗数据而不是筛选(considering)他们. 因此, 该算法将使用

    EditedNearestNeighbours和 3-NN分类器结果拒绝的样本之间的并集.

    from imblearn.under_sampling import NeighbourhoodCleaningRule
    ncr = NeighbourhoodCleaningRule(random_state=0)
    X_resampled, y_resampled = ncr.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[39]:
    [(0, 64), (1, 234), (2, 4666)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.2.2.4 Instance hardness threshold

    InstanceHardnessThreshold是一种很特殊的方法, 是在数据上运用一种分类器, 然后将概率低于阈值的样本剔除掉.

    from sklearn.linear_model import LogisticRegression
    from imblearn.under_sampling import InstanceHardnessThreshold
    iht = InstanceHardnessThreshold(random_state=0,
                                    estimator=LogisticRegression())
    X_resampled, y_resampled = iht.fit_sample(X, y)
    
    print(sorted(Counter(y_resampled).items()))
    Out[39]:
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    4. 过采样与下采样的结合

    在之前的SMOTE方法中, 当由边界的样本与其他样本进行过采样差值时, 很容易生成一些噪音数据. 因此, 在过采样之后需要对样本进行清洗. 这样, 第三节中涉及到的TomekLinkEditedNearestNeighbours方法就能实现上述的要求. 所以就有了两种结合过采样与下采样的方法: (i) SMOTETomek and (ii) SMOTEENN.

    from imblearn.combine import SMOTEENN
    smote_enn = SMOTEENN(random_state=0)
    X_resampled, y_resampled = smote_enn.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[40]:
    [(0, 4060), (1, 4381), (2, 3502)]
    
    
    from imblearn.combine import SMOTETomek
    smote_tomek = SMOTETomek(random_state=0)
    X_resampled, y_resampled = smote_tomek.fit_sample(X, y)
    
    print sorted(Counter(y_resampled).items())
    Out[40]:
    [(0, 4499), (1, 4566), (2, 4413)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    5. Ensemble的例子

    5.1 例子

    一个不均衡的数据集能够通过多个均衡的子集来实现均衡, imblearn.ensemble模块能实现上述功能.

    EasyEnsemble 通过对原始的数据集进行随机下采样实现对数据集进行集成.

    from imblearn.ensemble import EasyEnsemble
    ee = EasyEnsemble(random_state=0, n_subsets=10)
    X_resampled, y_resampled = ee.fit_sample(X, y)
    
    print X_resampled.shape
    print sorted(Counter(y_resampled[0]).items())
    Out[40]:
    (10L, 192L, 2L)
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    EasyEnsemble 有两个很重要的参数: (i) n_subsets 控制的是子集的个数 and (ii) replacement 决定是有放回还是无放回的随机采样.

    与上述方法不同的是, BalanceCascade(级联平衡)的方法通过使用分类器(estimator参数)来确保那些被错分类的样本在下一次进行子集选取的时候也能被采样到. 同样, n_max_subset 参数控制子集的个数, 以及可以通过设置bootstrap=True来使用bootstraping(自助法).

    from imblearn.ensemble import BalanceCascade
    from sklearn.linear_model import LogisticRegression
    bc = BalanceCascade(random_state=0,
                        estimator=LogisticRegression(random_state=0),
                        n_max_subset=4)
    X_resampled, y_resampled = bc.fit_sample(X, y)
    
    print X_resampled.shape
    
    print sorted(Counter(y_resampled[0]).items())
    Out[41]:
    (4L, 192L, 2L)
    [(0, 64), (1, 64), (2, 64)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    5.2 Chaining ensemble of samplers and estimators

    在集成分类器中, 装袋方法(Bagging)在不同的随机选取的数据集上建立了多个估计量. 在scikit-learn中这个分类器叫做BaggingClassifier. 然而, 该分类器并不允许对每个数据集进行均衡. 因此, 在对不均衡样本进行训练的时候, 分类器其实是有偏的, 偏向于多数类.

    from sklearn.model_selection import train_test_split
    from sklearn.metrics import confusion_matrix
    from sklearn.ensemble import BaggingClassifier
    from sklearn.tree import DecisionTreeClassifier
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
    bc = BaggingClassifier(base_estimator=DecisionTreeClassifier(),
                           random_state=0)
    bc.fit(X_train, y_train) 
    
    y_pred = bc.predict(X_test)
    confusion_matrix(y_test, y_pred)
    Out[35]:
    array([[   0,    0,   12],
           [   0,    0,   59],
           [   0,    0, 1179]], dtype=int64)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    BalancedBaggingClassifier 允许在训练每个基学习器之前对每个子集进行重抽样. 简而言之, 该方法结合了EasyEnsemble 采样器与分类器(如BaggingClassifier)的结果.

    from imblearn.ensemble import BalancedBaggingClassifier
    bbc = BalancedBaggingClassifier(base_estimator=DecisionTreeClassifier(),
                                    ratio='auto',
                                    replacement=False,
                                    random_state=0)
    bbc.fit(X, y) 
    
    y_pred = bbc.predict(X_test)
    confusion_matrix(y_test, y_pred)
    Out[39]:
    array([[  12,    0,    0],
           [   0,   55,    4],
           [  68,   53, 1058]], dtype=int64)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    6. 数据载入

    imblearn.datasets 包与sklearn.datasets 包形成了很好的互补. 该包主要有以下两个功能: (i)提供一系列的不平衡数据集来实现测试; (ii) 提供一种工具将原始的平衡数据转换为不平衡数据.

    6.1 不平衡数据集

    fetch_datasets 允许获取27个不均衡且二值化的数据集.

    from collections import Counter
    from imblearn.datasets import fetch_datasets
    ecoli = fetch_datasets()['ecoli']
    ecoli.data.shape
    
    print sorted(Counter(ecoli.target).items())
    Out[40]:
    [(-1, 301), (1, 35)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6.2 生成不平衡数据

    make_imbalance 方法可以使得原始的数据集变为不平衡的数据集, 主要是通过ratio参数进行控制.

    from sklearn.datasets import load_iris
    from imblearn.datasets import make_imbalance
    iris = load_iris()
    ratio = {0: 20, 1: 30, 2: 40}
    X_imb, y_imb = make_imbalance(iris.data, iris.target, ratio=ratio)
    
    sorted(Counter(y_imb).items())
    Out[37]:
    [(0, 20), (1, 30), (2, 40)]
    
    #当类别不指定时, 所有的数据集均导入
    ratio = {0: 10}
    X_imb, y_imb = make_imbalance(iris.data, iris.target, ratio=ratio)
    
    sorted(Counter(y_imb).items())
    Out[38]:
    [(0, 10), (1, 50), (2, 50)]
    
    #同样亦可以传入自定义的比例函数
    def ratio_multiplier(y):
        multiplier = {0: 0.5, 1: 0.7, 2: 0.95}
        target_stats = Counter(y)
        for key, value in target_stats.items():
            target_stats[key] = int(value * multiplier[key])
        return target_stats
    X_imb, y_imb = make_imbalance(iris.data, iris.target,
                                  ratio=ratio_multiplier)
    
    sorted(Counter(y_imb).items())
    Out[39]:
    [(0, 25), (1, 35), (2, 47)]
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    以上就是在研究不平衡(不均衡)数据时所查询的一些资料, 内容更多的是来自于Imblearn包的官方用户手册, 主要涉及一些下采样、过采样的方法与技术.

    参考资料

     


    1. 稀疏矩阵CRS存储
    2. 常见稀疏矩阵存储方法总结
    3. 稀疏矩阵存储Scipy官方文档
    4. SMOTE算法
    5. 不平衡数据处理
    6. Imblearn包官网
    7. Imblearn GitHub
    展开全文
  • imblearn安装

    万次阅读 2019-07-22 09:23:55
    在命令行中运行以下代码: conda install -c glemaitre imbalanced-learn 尝试运行: import imblearn 如果安装成功,则不会报错。

    在命令行中运行以下代码:

    conda install -c glemaitre imbalanced-learn

    尝试运行:

    import imblearn

    如果安装成功,则不会报错。

    展开全文
  • Py之imblearnimblearn/imbalanced-learn库的简介、安装、使用方法之详细攻略目录imblearn/imbalanced-learn库的简介imblearn/imbalanced-learn库的安装imblearn/imbalanced-learn库的使用方法imblearn/imbalanced-...
  • 我们希望为模型准备或分析的数据是完美的。但是数据可能有缺失的值、异常值和复杂的数据类型。我们需要做一些预处理来解决这些问题。但是有时我们在分类任务中会遇到不平衡的数据。...imblearn是一个开源的由麻省理工.
  • 报错: ERROR: Could not install packages due to an EnvironmentError: [WinError 5] 拒绝访问。... 看来加个 --user好像能解决的样子 然后我重新Win+R→cmd后输入:pip install --user imblearn 安装成功!
  • 怎么使用Python安装第三方库imblearn

    千次阅读 2020-12-22 15:15:17
    当使用的是anaconda spyder开发环境时,只要确保conda install 安装正确即可: 验证imblearn是否安装正确:打开Ipython,输入import imblearn,如果成功则不提示任何信息;如果没有,则会提示“找不到相关的模块”...
  • imblearn

    2020-03-24 15:31:32
    文章目录1. Under-sampling2. Over-sampling3. Combination4. Ensemble Learning 1. Under-sampling from sklearn.datasets import make_...from imblearn.under_sampling import RandomUnderSampler fro...
  • 安装前,需要保证自己的环境符合安装要求 ... 安装方法:打开Anaconda Prompt,输入 conda install -c conda-forge ...参考资料:在Anaconda上面安装imblearn包_tbcdn的博客-CSDN博客_anaconda安装imblearn库 ...
  • pip install imblearn -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com 如果不先卸载直接pip安装的话,在import的时候会有各种scikit-learn,numpy,scipy缺少模块 ...
  • from imblearn.datasets import make_imbalance from imblearn.under_sampling import NearMiss from imblearn.pipeline import make_pipeline from imblearn.metrics import classification_report_imbalanced How...
  • 我正在寻找使用imblearn的SMOTE为机器学习算法生成合成样本。我有几个分类特征,我已经使用sklearn预处理.LabelEncoder转换为整数。如何使用imblearn和SMOTE生成分类合成样本?我遇到的问题是,当我使用smote生成...
  • pip install imblearn # 调用 from imblearn.over_sampling import SMOTE # 使用SMOTE进行过采样时正样本和负样本要放在一起,生成比例1:1 smo = SMOTE(n_jobs=-1) # 这里必须是fit_resample(),有些版本是fit_...
  • 好在Python有Imblearn包,它就是为处理数据比例失衡而生的。 一.安装Imblearn包 pip3 install imblearn 二.过采样 正样本严重不足,那就补充正样本。使用imblearn包中的over_sampling进行过采样有如下几种方法。 1...
  • 安装地址:...Help on package imblearn: NAME imblearn - Toolbox for imbalanced dataset in machine learning. DESCRIPTION ``imbalanced-learn`` i...
  • 下载 conda install -c conda-forge imbalanced-learn https://blog.csdn.net/weixin_41013322/article/details/102963352
  • 我们在处理医疗诊断等问题,会遇到不平衡数据...在Python中,有个很好用的库imbalanced-learn——imblearn.在本博文,只借鉴论文进行关键点总结。 参考 先放参考,后文是我在阅读参考资料时整理的笔记,因此难免疏漏. 论...
  • 使用 imblearn 应对类别不均衡
  • Imblearn package study 1. 准备知识 1.1 Compressed Sparse Rows(CSR) 压缩稀疏的行 2. 过采样(Over-sampling) 2.1 实用性的例子 2.1.1 朴素随机过采样 2.1.2 从随机过采样到SMOTE与ADASYN 2.1.3...
  • anaconda上面安装imblearn

    千次阅读 2019-11-25 01:07:17
    如果上面的命令执行不下去,那就应该看看自己的环境是否符合imblearn的安装要求, 如果不满足要求,请更新后执行安装命令。主要是要更新scikit-learn的版本 更新scikit-learn的命令: conda update scikit-learn ...
  • python 使用imblearn处理非平衡数据

    千次阅读 2020-08-26 19:53:49
    集成分类方法:通过对较多的数据集抽样和较少数据集组成新的数据集,然后进行投票的方式进行分类 代码实现 使用sklearn的扩展库imblearn python 直接pip install i’m’b’learn imblearn详细使用: 函数详细介绍 过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,752
精华内容 700
关键字:

imblearn

友情链接: gun_nk60.zip