基于支持向量的数据重采样器

Question

赏金将在 6 天后到期。 此问题的答案有资格获得+150声望赏金。 arilwan想提请更多人注意这个问题：

带有示例工作代码的详细答案，在问题中引用了 WME。

我正在努力实现一个基于support vectors数据重采样器。 这个想法是适合SVM分类器，获得类的support vector点，然后通过仅选择每个 class 的支持向量点附近的数据点来平衡数据，以使类具有相同数量的示例，忽略所有其他（远离支持向量点）。

我在多类设置中这样做。 因此，我需要成对地对类进行重新采样（即one-against-one ）。 我知道在sklean 的 SVM中“......在内部，一对一（'ovo'）总是用作训练模型的多类策略” 。 但是，由于我不确定如何以在训练期间对每对重新采样的方式更改 sklearn 的 SVM 的训练行为，因此我实现了自定义 class 来执行此操作。

目前，自定义 class 工作正常。 但是，在我的实现中，我有一个错误（逻辑错误），它将每对 class 标签更改为0和1 ，从而弄乱了我的 class 标签。 在下面的代码中，我用MWE对此进行了说明：

# required imports
import random
from collections import Counter
from math import dist
import numpy as np
from sklearn.svm import SVC
from sklearn.utils import check_random_state
from sklearn.multiclass import OneVsOneClassifier
from imblearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

np.random.seed(7)
random.seed(7)

# resampler class
class DataUndersampler():
  def __init__(self, random_state=None):
    self.random_state = random_state
    print('DataUndersampler()')

  def fit_resample(self, X, y):
    random_state = check_random_state(self.random_state)
    # class distribution
    counter = Counter(y)
    print(f'Original class distribution: {counter}')
    maj_class = counter.most_common()[0][0]
    min_class = counter.most_common()[-1][0]
    # number of minority examples
    num_minority = len(X[ y == min_class])
    #num_majority = len(X[ y == maj_class]) # check on with maj now
    svc = SVC(kernel='rbf', random_state=32)
    svc.fit(X,y)
    # majority class support vectors
    maj_sup_vectors = svc.support_vectors_[maj_class]
    #min_sup_vectors = svc.support_vectors_[min_class] # minority sup vect
    # compute distances to support vectors' point
    distances = []
    for i, x in enumerate(X[y == maj_class]): 
      #input(f'sv: {maj_sup_vectors}, x: {x}') # check value passed
      d = dist(maj_sup_vectors, x) 
      distances.append((i, d))
    # sort distances (reverse=False -> ascending)
    distances.sort(reverse=False, key=lambda tup: tup[1])
    index = [i for i, d in distances][:num_minority] 
    X_ds = np.concatenate((X[y == maj_class][index], X[y == min_class]))
    y_ds = np.concatenate((y[y == maj_class][index], y[y == min_class]))
    print(f"Resampled class distribution ('ovo'): {Counter(y_ds)} \n")

    return X_ds, y_ds

所以，使用这个：

# synthetic data
X, y = make_classification(n_samples=10_000, n_classes=5, weights=[22.6, 3.7, 16.4, 51.9],
                           n_informative=4)

# actual class distribution
Counter(y)
Counter({0: 9924, 1: 22, 2: 15, 3: 13, 4: 26})

resampler = DataUndersampler(random_state=234)
rf_clf = model = RandomForestClassifier()

pipeline = Pipeline([('sampler', resampler), ('clf', rf_clf)])
classifier = OneVsOneClassifier(estimator=pipeline)
DataUndersampler()

classifier.fit(X, y)

Original class distribution: Counter({0: 9924, 1: 22})  
Resampled class distribution ('ovo'): Counter({0: 22, 1: 22}) 

Original class distribution: Counter({0: 9924, 1: 15}) # this should be {0: 9924, 2: 15}
Resampled class distribution ('ovo'): Counter({0: 15, 1: 15}) # should be-> {0: 9924, 2: 15}

Original class distribution: Counter({0: 9924, 1: 13}) # should be -> {0: 9924, 3: 13}
Resampled class distribution ('ovo'): Counter({0: 13, 1: 13}) # -> {0: 9924, 3: 13}

Original class distribution: Counter({0: 9924, 1: 26}) # should be-> {0: 9924, 4: 26}
Resampled class distribution ('ovo'): Counter({0: 26, 1: 26}) # -> {0: 9924, 4: 26}

Original class distribution: Counter({0: 22, 1: 15}) # should be > {1: 22, 2: 15}
Resampled class distribution ('ovo'): Counter({0: 15, 1: 15}) # -> {1: 22, 2: 15}

Original class distribution: Counter({0: 22, 1: 13}) # -> {1: 22, 3: 13}
Resampled class distribution ('ovo'): Counter({0: 13, 1: 13}) ## -> {1: 22, 3: 13}

Original class distribution: Counter({1: 26, 0: 22}) # -> {4: 26, 1: 22}
Resampled class distribution ('ovo'): Counter({1: 22, 0: 22}) # -> {4: 26, 1: 22}

Original class distribution: Counter({0: 15, 1: 13}) # -> {2: 15, 3: 13}
Resampled class distribution ('ovo'): Counter({0: 13, 1: 13}) # -> {2: 15, 3: 13}

Original class distribution: Counter({1: 26, 0: 15}) # -> {4: 26, 2: 15}
Resampled class distribution ('ovo'): Counter({1: 15, 0: 15}) # -> {4: 26, 2: 15}

Original class distribution: Counter({1: 26, 0: 13}) # -> {4: 26, 3: 13}
Resampled class distribution ('ovo'): Counter({1: 13, 0: 13}) # -> {4: 26, 3: 13}

我该如何解决？

Answer 1

问题：

在您的代码中，class 标签由于OneVsOneClassifier内部工作方式而变得混乱。 它将原来的多分类问题转化为多个二分类问题。 对于这些二元问题中的每一个，类都被重新标记为0和1 ，这就是为什么您在 output 中只看到0和1的原因。

问题，详细：

当您使用OneVsOneClassifier时，它会在内部构建多个二元分类器，每个分类器仅在两个原始类上进行训练。 对于这些二元分类器中的每一个，class 标签被转换为0和1 。 此转换由OneVsOneClassifier在内部完成，以处理二元分类问题。

现在，当您在DataUndersampler class 内部时，您收到的标签y是这些转换后的标签0和1 ，而不是来自多类问题的原始标签。 这就是为什么DataUndersampler.fit_resample()中的打印语句显示带有键0和1的Counter对象。

下面是一个例子来说明这是如何发生的：

假设您有一个包含 3 个类的多类问题，分别标记为0 、 1和2 。 当应用OneVsOneClassifier时，它将创建 3 个二进制分类器：一个用于 class 0 vs class 1 ，一个用于 class 0 vs class 2 ，一个用于 class 1 vs 88 398112195188 2 ．

现在，对于这些二元分类器中的每一个，类都被重新标记为0和1 。 这意味着，对于第一个分类器（类0与 class 1 ），原来的 class 0可能被重新标记为0 ，而原来的 class 1可能被重新标记为1 。 但是对于第二个分类器（类0与 class 2 ），原来的 class 0可能被重新标记为0 ，而原来的 class 2可能被重新标记为1 。 类似地，对于第三个分类器（ 1类与 class 2 ），原来的 class 1可能被重新标记为0 ，而原来的 class 2可能被重新标记为1 。

当您的DataUndersampler.fit_resample()方法接收到y时，它接收的是这些转换后的标签，而不是多类问题中的原始标签。

关键是重新标记为0和1是为每个二元分类器独立完成的，并且不保留原始标签。 这就是为什么您在 output 中只看到0和1 ，这就是我说“class 标签被弄乱了”的意思。 这并不是标签分配不正确，而是标签分配不正确。 相反，对于每个二元分类问题，原始标签都被转换为0和1 ，这不是您所期望的。

为了跟踪原始标签，您需要在转换之前存储它们，然后在完成重采样后将 map 二进制标签恢复为原始标签。

可能的解决方案：

要解决此问题，您可以改用scikit-learn-contrib/imbalanced-learn库 ( pip install -U imbalanced-learn )。
它的RandomUnderSampler在内部处理重新标记问题并确保保留原始 class 标签。

在最初的实现中，class 标签变得“混乱”，因为OneVsOneClassifier将多类问题转换为多个二元分类问题。 对于每个二元问题，类都被重新标记为 0 和 1。这就是为什么您在 output 中只看到 0 和 1，即使您的原始数据具有不同的标签。

使用RandomUnderSampler ，将保留 class 个标签。 RandomUnderSampler通过随机选择多数 class 的子集来创建新的平衡数据集。 这个新数据集中使用了原始数据集中的 class 个标签。

因此，在新的实现中，无需维护从原始 class 标签到二进制标签的映射，因为RandomUnderSampler会为您处理此问题。 这是使用像不平衡学习这样的专门库的好处之一，它为机器学习中的常见问题提供了可靠的解决方案。

这是DataUndersampler class 的修改版本，它跟踪原始标签及其使用方式：

from collections import Counter
from imblearn.under_sampling import RandomUnderSampler
from sklearn.ensemble import RandomForestClassifier
from sklearn.multiclass import OneVsOneClassifier
from sklearn.pipeline import Pipeline
from sklearn.datasets import make_classification
import numpy as np

class DataUndersampler:
    def __init__(self):
        self.sampler = RandomUnderSampler(random_state=42)

    def fit(self, X, y):
        self.sampler.fit_resample(X, y)
        return self

    def transform(self, X, y):
        X_res, y_res = self.sampler.fit_resample(X, y)
        return X_res, y_res

# Create a dummy dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=2, n_redundant=10, n_classes=3, weights=[0.01, 0.01, 0.98], class_sep=0.8, random_state=42)

# initialize your undersampler
undersampler = DataUndersampler()

# fit the undersampler and transform the data
X_resampled, y_resampled = undersampler.fit(X, y).transform(X, y)

print(f"Original class distribution: {Counter(y)}")
print(f"Resampled class distribution: {Counter(y_resampled)}")

# initialize the pipeline (without the undersampler)
pipeline = Pipeline([
    ('clf', OneVsOneClassifier(RandomForestClassifier(random_state=42)))
])

# fit the pipeline on the resampled data
pipeline.fit(X_resampled, y_resampled)

# now you can use your pipeline to predict
# y_pred = pipeline.predict(X_test)  # assuming you have a test set X_test

我已经注释掉最后一行，因为这段代码中没有定义X_test 。 如果您有一个单独的测试集，您可以取消注释该行以进行预测。

主要变化如下：

1. 使用RandomUnderSampler而不是手动实现欠采样。 这消除了对_undersample function 的需要，并显着简化了fit和transform方法。

2. fit方法现在只使RandomUnderSampler适合数据并返回self 。 这是因为 scikit-learn 管道中变压器的fit方法预计会返回self 。

3. transform方法将拟合的RandomUnderSampler应用于数据并返回欠采样数据。

这些更改背后的主要思想是尽可能利用现有的库和约定，使代码更简单、更易于理解和更易于维护。

MWE

最小工作示例 (MWE) 现在是：

from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.multiclass import OneVsOneClassifier
from imblearn.under_sampling import RandomUnderSampler
from collections import Counter

# synthetic data
X, y = make_classification(n_samples=10_000, n_classes=5, weights=[22.6, 3.7, 16.4, 51.9],
                           n_informative=4)

print("Original class distribution:", Counter(y))

resampler = RandomUnderSampler(random_state=234)
rf_clf = RandomForestClassifier()

pipeline = Pipeline([('sampler', resampler), ('clf', rf_clf)])
classifier = OneVsOneClassifier(estimator=pipeline)

classifier.fit(X, y)

# predict and evaluate
y_pred = classifier.predict(X)
print("Predicted class distribution:", Counter(y_pred))

在这个更新的代码中：

1. 我们正在从不平衡学习中导入RandomUnderSampler 。
2. 我们将管道中的DataUndersampler替换为RandomUnderSampler 。
3. 我们删除了与 resampled class 分布相关的打印语句，因为RandomUnderSampler不直接提供此信息。 但是，您仍然可以在训练分类器后获得预测类别的分布。

此代码应该可以在没有您之前遇到的 label 问题的情况下运行。 此外，它应该比原来的 MWE 更短、更简洁。

---

我们想要拟合一个 SVC 以确定每对类中的支持向量，然后忽略距离其支持向量更远的多数 class 的示例，直到我们实现数据平衡（ n_majority = n_minority示例）。

支持基于向量的欠采样

因此，您的目标是以更明智的方式对大多数 class 进行欠采样，同时考虑数据的结构，而不仅仅是随机的。

我们需要修改DataUndersampler以执行此策略。
主要思想是将SVC——C 支持向量分类拟合到数据，找到支持向量，然后根据到这些支持向量的距离对大多数 class 进行欠采样。

from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.utils import resample
from sklearn.svm import SVC
import numpy as np

class DataUndersampler(BaseEstimator, TransformerMixin):
    def __init__(self, random_state=None):
        self.random_state = random_state
        self.svc = SVC(kernel='linear')

    def fit(self, X, y):
        # Fit SVC to data
        self.svc.fit(X, y)
        return self

    def transform(self, X, y):
        # Get support vectors
        support_vectors = self.svc.support_vectors_
        # Get indices of support vectors
        support_vector_indices = self.svc.support_

        # Separate majority and minority classes
        majority_class = y.value_counts().idxmax()
        minority_class = y.value_counts().idxmin()
        X_majority = X[y == majority_class]
        y_majority = y[y == majority_class]
        X_minority = X[y == minority_class]
        y_minority = y[y == minority_class]

        # Calculate distances of majority class samples to nearest support vector
        distances = np.min(np.linalg.norm(X_majority.values[:, np.newaxis] - support_vectors, axis=2), axis=1)

        # Sort the majority class samples by distance and take only as many as there are in minority class
        sorted_indices = np.argsort(distances)
        indices_to_keep = sorted_indices[:len(y_minority)]

        # Combine the undersampled majority class with the minority class
        X_resampled = pd.concat([X_majority.iloc[indices_to_keep], X_minority])
        y_resampled = pd.concat([y_majority.iloc[indices_to_keep], y_minority])

        return X_resampled, y_resampled

您可以像以前一样在管道中使用此转换器：

resampler = DataUndersampler(random_state=234)
pipeline = Pipeline([('sampler', resampler), ('clf', rf_clf)])
classifier = OneVsOneClassifier(estimator=pipeline)
classifier.fit(X, y)

这种方法在欠采样时会尊重数据结构，因为它使用 SVM 的支持向量来指导欠采样过程。 它还应该解决标签不正确的问题。
但是，请注意，由于需要拟合 SVM 并计算距离以支持每对类别的向量，因此这将比随机欠采样在计算上更加昂贵。

新的DataUndersampler class 与原来的有很大不同，因为它使用了不同的欠采样策略。
以下是主要区别：

1. 支持向量分类器 (SVC)：新的 class 在fit方法中将 SVC 拟合到数据。 这是一个主要区别，因为原始 class 没有使用任何学习算法。 SVC 用于查找支持向量，支持向量是定义类之间决策边界的数据点。

2. 支持向量和距离：新的 class 使用支持向量来计算大多数 class 中的每个数据点到其最近的支持向量的距离。 此信息用于对大多数 class 进行欠采样，保留最接近支持向量的数据点。 相比之下，原来的class采用了随机欠采样策略，没有考虑数据的结构。

3. 重采样：新的 class 根据计算出的距离对大多数 class 进行欠采样，保留与少数 class 中一样多的数据点。这确保了类是平衡的，而且保留的大多数 class 数据点是那些信息量最大，因为它们接近决策边界。
   最初的 class 也是为了平衡类别，但它通过随机丢弃大多数 class 的数据点来实现。

4. 不再重新标记：新的 class 不需要将类重新标记为0和1 ，这会导致原始代码出现问题。
   这些类保持原样，因为 SVC 可以处理原始标签。

5. Pandas：新代码使用 pandas 进行数据操作（例如，分离多数类和少数类，对数据重新采样）。 原来的class用了numpy arrays。

6. Scikit-learn 兼容性：与原来的 class 一样，新的 class 从 scikit-learn 扩展了BaseEstimator和TransformerMixin类，因此它可以用作 scikit-learn 管道的一部分。 fit和transform方法分别用于拟合 SVC 和欠采样数据。

修订后的DataUndersampler class 中使用的新欠采样策略本质上是一种称为基于支持向量的欠采样的方法。

在此策略中，核心思想是将支持向量机 (SVM)分类器与数据相匹配，该分类器识别数据点，称为支持向量，定义类之间的决策边界。

然后，对于大多数 class 中的每个数据点，计算到最近的支持向量的距离。 这里的基本原理是来自大多数 class 的最接近决策边界（即支持向量）的数据点对于分类任务来说是最有用的，因为它们位于大多数 class 的“边缘”并且最接近少数民族 class。

然后将多数 class 中的数据点按照这个距离进行排序，丢弃距离决策边界最远的数据点，直到多数 class 中的数据点数等于少数 class 中的数据点数. 这有效地对大多数 class 进行了欠采样，同时保留了其信息量最大的数据点。

此策略不同于DataUndersampler class 中的原始策略，它只是随机丢弃大多数 class 中的数据点，直到类达到平衡。 基于支持向量的欠采样策略是一种更复杂、更有针对性的方法，因为它在决定丢弃哪些数据点时会考虑数据的结构。