多类别不平衡分类问题与SMOTE技术实践

1. 多类别不平衡分类问题概述

在机器学习实践中，我们经常会遇到类别分布不均衡的分类问题。这类问题中，某些类别的样本数量可能远多于其他类别，导致模型训练时倾向于忽略少数类。虽然大多数关于不平衡分类的研究都集中在二分类问题上，但多类别不平衡问题同样普遍存在且具有挑战性。

玻璃识别数据集就是一个典型的多类别不平衡分类问题。该数据集包含214个玻璃样本，根据化学成分需要将其分类为6种类型（原始有7类，但第4类在数据集中没有样本）。各类别的样本数量差异显著：最多的类别有76个样本，而最少的仅有9个样本。

关键提示：在多类别不平衡问题中，所有类别通常都同等重要，不能因为某些类别样本少就降低其重要性。这与某些场景下可以接受牺牲少数类精度的情况不同。

2. 数据集详解与探索性分析

2.1 数据集特征解析

玻璃识别数据集包含以下9个化学特征：

1. RI：折射率
2. Na：钠含量(氧化物重量百分比)
3. Mg：镁含量
4. Al：铝含量
5. Si：硅含量
6. K：钾含量
7. Ca：钙含量
8. Ba：钡含量
9. Fe：铁含量

目标变量为玻璃类型，编码为1-6类（原始类别中的第4类在数据集中不存在）：

2.2 数据不平衡可视化分析

通过Python代码可以直观展示类别分布的不平衡性：

import pandas as pd from collections import Counter import matplotlib.pyplot as plt from sklearn.preprocessing import LabelEncoder url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/glass.csv' df = pd.read_csv(url, header=None) data = df.values X, y = data[:, :-1], data[:, -1] # 标签编码 y = LabelEncoder().fit_transform(y) # 统计类别分布 counter = Counter(y) for k,v in counter.items(): per = v / len(y) * 100 print(f'Class={k}, n={v} ({per:.1f}%)') # 绘制分布图 plt.bar(counter.keys(), counter.values()) plt.xlabel('Class') plt.ylabel('Count') plt.title('Class Distribution in Glass Dataset') plt.show()

执行后会输出各类别的数量占比，并生成直观的柱状图。从结果可见，类别1和2合计占约68%，而其他类别样本稀少，最少的类别6仅占4.2%。

3. SMOTE过采样技术实践

3.1 SMOTE基础原理

SMOTE(Synthetic Minority Over-sampling Technique)是一种通过合成新样本来解决类别不平衡问题的技术。其核心思想是在少数类样本的特征空间中找到近邻，然后在这些样本之间随机插值生成新样本。

算法步骤：

1. 对于少数类中的每个样本x，找到其k个最近邻(通常k=5)
2. 随机选择其中一个近邻x'
3. 在x和x'之间的连线上随机选择一个点作为新样本
4. 重复过程直到达到所需的样本量

3.2 基础SMOTE实现

使用imbalanced-learn库实现基础SMOTE：

from imblearn.over_sampling import SMOTE # 应用SMOTE oversample = SMOTE() X_res, y_res = oversample.fit_resample(X, y) # 查看新分布 new_counter = Counter(y_res) for k,v in new_counter.items(): print(f'Class={k}, n={v}')

默认情况下，SMOTE会使所有类别的样本数与最多的类别相同（本例中各类别都将有76个样本）。这种策略简单直接，但可能导致过度采样，特别是当原始多数类本身样本量很大时。

3.3 自定义采样策略

更合理的做法是根据实际需求定制每个类别的目标样本量。例如，我们希望将少数类增加到多数类的1.5倍：

import numpy as np # 计算原始分布 original_counts = np.bincount(y) majority_count = np.max(original_counts) # 设置采样策略 strategy = { 0: int(majority_count * 1.5), # 类别0增加到114 1: majority_count, # 类别1保持76 2: int(majority_count * 1.2), # 类别2增加到91 3: int(majority_count * 1.5), 4: int(majority_count * 1.5), 5: int(majority_count * 1.3) } oversample = SMOTE(sampling_strategy=strategy) X_res_custom, y_res_custom = oversample.fit_resample(X, y)

重要提示：SMOTE只应在训练集上应用，而不是在整个数据集上。在交叉验证中，应该在每次折叠的训练部分应用SMOTE，测试部分保持原始分布。可以使用Pipeline实现这一过程。

4. 代价敏感学习方法

4.1 代价敏感学习原理

代价敏感学习通过为不同类别的错误分类分配不同的代价，使模型在训练时更关注少数类。在随机森林等算法中，可以通过class_weight参数实现。

常见策略：

• 'balanced'：自动计算权重，与类别频率成反比
• 'balanced_subsample'：类似于balanced，但在每次bootstrap采样时计算
• 自定义字典：手动指定每个类别的权重

4.2 基础代价敏感随机森林

from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_score # 基准模型(不处理不平衡) model = RandomForestClassifier(n_estimators=1000) scores = cross_val_score(model, X, y, cv=5, scoring='accuracy') print(f'Baseline Accuracy: {np.mean(scores):.3f}') # 代价敏感模型 model_cs = RandomForestClassifier(n_estimators=1000, class_weight='balanced') scores_cs = cross_val_score(model_cs, X, y, cv=5, scoring='accuracy') print(f'Cost-sensitive Accuracy: {np.mean(scores_cs):.3f}')

在实际测试中，代价敏感版本通常能获得1-3%的准确率提升，更重要的是能改善少数类的召回率。

4.3 自定义权重策略

根据业务需求，我们可以为不同类别分配不同的误分类代价。例如，假设类别3和5在实际应用中更重要：

# 自定义权重 weights = { 0: 1.0, # 基础权重 1: 1.0, 2: 1.5, # 提高权重 3: 2.0, # 最重要类别 4: 1.2, 5: 1.8 # 次重要类别 } model_custom = RandomForestClassifier(n_estimators=1000, class_weight=weights) scores_custom = cross_val_score(model_custom, X, y, cv=5, scoring='accuracy') print(f'Custom weighted Accuracy: {np.mean(scores_custom):.3f}')

5. 综合评估与比较

5.1 方法对比实验

我们系统比较三种处理不平衡的方法：

1. 不处理(基线)
2. SMOTE过采样
3. 代价敏感学习

使用宏平均F1分数作为评估指标（更适合不平衡数据）：

from sklearn.model_selection import RepeatedStratifiedKFold from sklearn.metrics import f1_score, make_scorer # 定义评估流程 cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=1) scorer = make_scorer(f1_score, average='macro') # 评估三种策略 models = { 'Baseline': RandomForestClassifier(n_estimators=1000), 'SMOTE': make_pipeline(SMOTE(), RandomForestClassifier(n_estimators=1000)), 'Cost-sensitive': RandomForestClassifier(n_estimators=1000, class_weight='balanced') } results = [] for name, model in models.items(): scores = cross_val_score(model, X, y, cv=cv, scoring=scorer, n_jobs=-1) results.append(scores) print(f'{name}: Mean F1={np.mean(scores):.3f}, Std={np.std(scores):.3f}')

5.2 结果分析与选择建议

实验结果显示：

选择建议：

• 当计算资源有限且样本量足够时，优先考虑代价敏感学习
• 当少数类样本绝对数量很少时，SMOTE可能更有效
• 对于关键应用，可以尝试结合两种方法

6. 实战经验与技巧

6.1 SMOTE使用注意事项

1. 特征标准化：SMOTE基于距离度量，连续特征应标准化：

   from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler pipeline = make_pipeline( StandardScaler(), SMOTE(), RandomForestClassifier() )

2. 分类变量处理：原始SMOTE不支持分类变量。对于混合类型数据：

   • 使用SMOTENC(专门处理分类特征的变体)
   • 将分类变量转换为数值表示

3. 维度灾难：高维数据中距离度量可能失效，可先进行特征选择：

   from sklearn.feature_selection import SelectKBest pipeline = make_pipeline( SelectKBest(k=10), SMOTE(), RandomForestClassifier() )

6.2 代价敏感学习调优技巧

1. 权重搜索：使用网格搜索寻找最优权重组合：

   from sklearn.model_selection import GridSearchCV param_grid = { 'class_weight': [ 'balanced', {0:1,1:1,2:2,3:2,4:2,5:2}, {0:1,1:1,2:3,3:3,4:2,5:2} ] } grid = GridSearchCV(RandomForestClassifier(), param_grid, cv=5, scoring='f1_macro') grid.fit(X, y)

2. 代价矩阵：对于更复杂的代价需求，可以实现自定义代价矩阵：

   from sklearn.utils.class_weight import compute_sample_weight # 定义代价矩阵 cost_matrix = [ [0, 1, 2, 2, 2, 2], # 将类别0错分为其他类的代价 [1, 0, 2, 2, 2, 2], [2, 2, 0, 3, 3, 3], [3, 3, 3, 0, 2, 2], [2, 2, 2, 2, 0, 1], [2, 2, 3, 3, 1, 0] ] # 转换为样本权重 sample_weight = compute_sample_weight(cost_matrix, y) model.fit(X, y, sample_weight=sample_weight)

6.3 其他实用技巧

1. 集成方法：结合过采样和欠采样：

   from imblearn.ensemble import BalancedRandomForestClassifier model = BalancedRandomForestClassifier(n_estimators=1000)

2. 评估指标选择：除了准确率，关注：

   • 宏平均F1(每个类同等重要)
   • 加权F1(考虑类别比例)
   • 混淆矩阵(分析具体哪些类容易被混淆)

3. 阈值调整：训练后调整分类阈值：

   from sklearn.calibration import calibration_curve probas = model.predict_proba(X_test) # 寻找最优阈值

在实际项目中，我通常会先尝试代价敏感学习，因为它的实现简单且计算成本低。如果效果不理想，再考虑SMOTE或其他过采样技术。最重要的是根据业务需求选择合适的评估指标，而不仅仅是准确率。