掌握Scikit-learn处理不平衡数据集的核心策略从数据重采样到算法调整全面解决机器学习模型性能问题

威震华夏关云长

引言

在现实世界的机器学习应用中，不平衡数据集是一个常见且具有挑战性的问题。不平衡数据集指的是在分类问题中，不同类别的样本数量存在显著差异。例如，在欺诈检测中，欺诈交易可能只占总交易的0.1%；在疾病诊断中，罕见疾病的样本可能远少于常见疾病。这种不平衡会导致机器学习模型倾向于多数类，从而对少数类的预测性能较差。

Scikit-learn作为Python中最流行的机器学习库之一，提供了多种处理不平衡数据集的工具和方法。本文将全面介绍如何使用Scikit-learn处理不平衡数据集，从数据重采样技术到算法调整方法，帮助读者掌握解决机器学习模型在不平衡数据上性能问题的核心策略。

不平衡数据集的挑战

不平衡数据集带来的主要挑战包括：

1. 偏向性预测：模型倾向于预测多数类，因为这样可以获得较高的准确率，但对少数类的识别能力较差。
2. 评估指标误导：准确率（Accuracy）在不平衡数据集上可能产生误导。例如，在一个99%负样本和1%正样本的数据集上，一个总是预测负类的模型也能达到99%的准确率，但实际上毫无用处。
3. 决策边界偏移：不平衡数据会导致决策边界向少数类偏移，使得少数类的样本更容易被错误分类。
4. 训练不充分：少数类的样本数量不足，导致模型无法充分学习其特征分布。

偏向性预测：模型倾向于预测多数类，因为这样可以获得较高的准确率，但对少数类的识别能力较差。

评估指标误导：准确率（Accuracy）在不平衡数据集上可能产生误导。例如，在一个99%负样本和1%正样本的数据集上，一个总是预测负类的模型也能达到99%的准确率，但实际上毫无用处。

决策边界偏移：不平衡数据会导致决策边界向少数类偏移，使得少数类的样本更容易被错误分类。

训练不充分：少数类的样本数量不足，导致模型无法充分学习其特征分布。

让我们通过一个简单的例子来说明这个问题：

2. import numpy as np
3. from sklearn.datasets import make_classification
4. from sklearn.model_selection import train_test_split
5. from sklearn.linear_model import LogisticRegression
6. from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
8. # 创建一个不平衡数据集
9. X, y = make_classification(n_samples=10000, n_features=20, n_classes=2,
10.                           weights=[0.95, 0.05], random_state=42)
12. # 划分训练集和测试集
13. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
15. # 训练一个逻辑回归模型
16. model = LogisticRegression(random_state=42)
17. model.fit(X_train, y_train)
19. # 预测
20. y_pred = model.predict(X_test)
22. # 评估
23. print("准确率:", accuracy_score(y_test, y_pred))
24. print("\n混淆矩阵:\n", confusion_matrix(y_test, y_pred))
25. print("\n分类报告:\n", classification_report(y_test, y_pred))

复制代码

输出结果可能显示高准确率，但对少数类（类别1）的召回率（Recall）和F1分数很低，这表明模型对少数类的识别能力较差。

评估指标

在不平衡数据集上，传统的准确率指标往往不足以评估模型性能。以下是一些更适合评估不平衡数据集上模型性能的指标：

1. 混淆矩阵（Confusion Matrix）：提供真正例（TP）、真负例（TN）、假正例（FP）和假负例（FN）的详细信息。
2. 精确率（Precision）：TP / (TP + FP)，表示预测为正例的样本中实际为正例的比例。
3. 召回率（Recall）或灵敏度（Sensitivity）：TP / (TP + FN)，表示实际为正例的样本中被正确预测为正例的比例。
4. F1分数（F1-Score）：2 * (Precision * Recall) / (Precision + Recall)，精确率和召回率的调和平均数。
5. 特异度（Specificity）：TN / (TN + FP)，表示实际为负例的样本中被正确预测为负例的比例。
6. ROC曲线和AUC值：ROC曲线绘制真正例率（TPR）与假正例率（FPR）之间的关系，AUC值表示ROC曲线下的面积，值越接近1表示模型性能越好。
7. PR曲线（Precision-Recall Curve）：在不平衡数据集中，PR曲线通常比ROC曲线更能反映模型性能，特别是当少数类样本非常少时。

混淆矩阵（Confusion Matrix）：提供真正例（TP）、真负例（TN）、假正例（FP）和假负例（FN）的详细信息。

精确率（Precision）：TP / (TP + FP)，表示预测为正例的样本中实际为正例的比例。

召回率（Recall）或灵敏度（Sensitivity）：TP / (TP + FN)，表示实际为正例的样本中被正确预测为正例的比例。

F1分数（F1-Score）：2 * (Precision * Recall) / (Precision + Recall)，精确率和召回率的调和平均数。

特异度（Specificity）：TN / (TN + FP)，表示实际为负例的样本中被正确预测为负例的比例。

ROC曲线和AUC值：ROC曲线绘制真正例率（TPR）与假正例率（FPR）之间的关系，AUC值表示ROC曲线下的面积，值越接近1表示模型性能越好。

PR曲线（Precision-Recall Curve）：在不平衡数据集中，PR曲线通常比ROC曲线更能反映模型性能，特别是当少数类样本非常少时。

在Scikit-learn中，我们可以使用以下代码计算这些指标：

2. from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score, average_precision_score, roc_curve, precision_recall_curve
3. import matplotlib.pyplot as plt
5. # 计算各项指标
6. precision = precision_score(y_test, y_pred)
7. recall = recall_score(y_test, y_pred)
8. f1 = f1_score(y_test, y_pred)
9. roc_auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])
10. pr_auc = average_precision_score(y_test, model.predict_proba(X_test)[:, 1])
12. print(f"精确率: {precision:.4f}")
13. print(f"召回率: {recall:.4f}")
14. print(f"F1分数: {f1:.4f}")
15. print(f"ROC AUC: {roc_auc:.4f}")
16. print(f"PR AUC: {pr_auc:.4f}")
18. # 绘制ROC曲线
19. fpr, tpr, _ = roc_curve(y_test, model.predict_proba(X_test)[:, 1])
20. plt.figure(figsize=(12, 5))
21. plt.subplot(1, 2, 1)
22. plt.plot(fpr, tpr, label=f'ROC Curve (AUC = {roc_auc:.2f})')
23. plt.plot([0, 1], [0, 1], 'k--')
24. plt.xlabel('False Positive Rate')
25. plt.ylabel('True Positive Rate')
26. plt.title('ROC Curve')
27. plt.legend()
29. # 绘制PR曲线
30. precision_curve, recall_curve, _ = precision_recall_curve(y_test, model.predict_proba(X_test)[:, 1])
31. plt.subplot(1, 2, 2)
32. plt.plot(recall_curve, precision_curve, label=f'PR Curve (AUC = {pr_auc:.2f})')
33. plt.xlabel('Recall')
34. plt.ylabel('Precision')
35. plt.title('Precision-Recall Curve')
36. plt.legend()
38. plt.tight_layout()
39. plt.show()

复制代码

数据重采样技术

数据重采样是处理不平衡数据集的常用方法，主要包括过采样、欠采样和混合采样。

过采样（Oversampling）

过采样通过增加少数类样本的数量来平衡数据集。最简单的过采样方法是随机复制少数类样本，但这可能导致过拟合。更高级的方法包括SMOTE（Synthetic Minority Over-sampling Technique）和ADASYN（Adaptive Synthetic Sampling）。

2. from sklearn.datasets import make_classification
3. from sklearn.model_selection import train_test_split
4. from collections import Counter
6. # 创建不平衡数据集
7. X, y = make_classification(n_samples=5000, n_features=20, n_classes=2,
8.                           weights=[0.95, 0.05], random_state=42)
10. print("原始数据集类别分布:", Counter(y))
12. # 划分训练集和测试集
13. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
15. # 随机过采样
16. from imblearn.over_sampling import RandomOverSampler
18. ros = RandomOverSampler(random_state=42)
19. X_resampled, y_resampled = ros.fit_resample(X_train, y_train)
21. print("过采样后训练集类别分布:", Counter(y_resampled))
23. # 训练模型
24. from sklearn.linear_model import LogisticRegression
25. from sklearn.metrics import classification_report
27. model = LogisticRegression(random_state=42)
28. model.fit(X_resampled, y_resampled)
30. # 预测并评估
31. y_pred = model.predict(X_test)
32. print("\n使用随机过采样的分类报告:\n", classification_report(y_test, y_pred))

复制代码

SMOTE通过在少数类样本之间插值来生成合成样本，而不是简单地复制现有样本。

2. from imblearn.over_sampling import SMOTE
4. # 应用SMOTE
5. smote = SMOTE(random_state=42)
6. X_smote, y_smote = smote.fit_resample(X_train, y_train)
8. print("SMOTE后训练集类别分布:", Counter(y_smote))
10. # 训练模型
11. model_smote = LogisticRegression(random_state=42)
12. model_smote.fit(X_smote, y_smote)
14. # 预测并评估
15. y_pred_smote = model_smote.predict(X_test)
16. print("\n使用SMOTE的分类报告:\n", classification_report(y_test, y_pred_smote))

复制代码

ADASYN是SMOTE的改进版本，它根据少数类样本的学习难度自适应地生成合成样本。对于更难学习的少数类样本，生成更多的合成样本。

2. from imblearn.over_sampling import ADASYN
4. # 应用ADASYN
5. adasyn = ADASYN(random_state=42)
6. X_adasyn, y_adasyn = adasyn.fit_resample(X_train, y_train)
8. print("ADASYN后训练集类别分布:", Counter(y_adasyn))
10. # 训练模型
11. model_adasyn = LogisticRegression(random_state=42)
12. model_adasyn.fit(X_adasyn, y_adasyn)
14. # 预测并评估
15. y_pred_adasyn = model_adasyn.predict(X_test)
16. print("\n使用ADASYN的分类报告:\n", classification_report(y_test, y_pred_adasyn))

复制代码

欠采样（Undersampling）

欠采样通过减少多数类样本的数量来平衡数据集。简单随机欠采样可能会丢失重要信息，因此更高级的方法如Tomek Links和NearMiss被提出。

2. from imblearn.under_sampling import RandomUnderSampler
4. # 应用随机欠采样
5. rus = RandomUnderSampler(random_state=42)
6. X_rus, y_rus = rus.fit_resample(X_train, y_train)
8. print("随机欠采样后训练集类别分布:", Counter(y_rus))
10. # 训练模型
11. model_rus = LogisticRegression(random_state=42)
12. model_rus.fit(X_rus, y_rus)
14. # 预测并评估
15. y_pred_rus = model_rus.predict(X_test)
16. print("\n使用随机欠采样的分类报告:\n", classification_report(y_test, y_pred_rus))

复制代码

Tomek Links是指两个不同类别的样本互为最近邻的情况。通过移除Tomek Links中的多数类样本，可以增加两类之间的决策边界。

2. from imblearn.under_sampling import TomekLinks
4. # 应用Tomek Links
5. tl = TomekLinks()
6. X_tl, y_tl = tl.fit_resample(X_train, y_train)
8. print("Tomek Links后训练集类别分布:", Counter(y_tl))
10. # 训练模型
11. model_tl = LogisticRegression(random_state=42)
12. model_tl.fit(X_tl, y_tl)
14. # 预测并评估
15. y_pred_tl = model_tl.predict(X_test)
16. print("\n使用Tomek Links的分类报告:\n", classification_report(y_test, y_pred_tl))

复制代码

NearMiss是一组欠采样方法，基于少数类样本选择多数类样本。NearMiss-1选择离少数类样本最近的多数类样本；NearMiss-2选择离少数类样本最远的多数类样本；NearMiss-3使用k近邻算法选择多数类样本。

2. from imblearn.under_sampling import NearMiss
4. # 应用NearMiss-1
5. nm = NearMiss(version=1)
6. X_nm, y_nm = nm.fit_resample(X_train, y_train)
8. print("NearMiss-1后训练集类别分布:", Counter(y_nm))
10. # 训练模型
11. model_nm = LogisticRegression(random_state=42)
12. model_nm.fit(X_nm, y_nm)
14. # 预测并评估
15. y_pred_nm = model_nm.predict(X_test)
16. print("\n使用NearMiss-1的分类报告:\n", classification_report(y_test, y_pred_nm))

复制代码

混合采样

混合采样结合了过采样和欠采样的优点，例如SMOTEENN和SMOTETomek。

SMOTEENN首先应用SMOTE进行过采样，然后应用ENN（Edited Nearest Neighbours）进行欠采样，移除被其他类别样本包围的样本。

2. from imblearn.combine import SMOTEENN
4. # 应用SMOTEENN
5. smote_enn = SMOTEENN(random_state=42)
6. X_smoteenn, y_smoteenn = smote_enn.fit_resample(X_train, y_train)
8. print("SMOTEENN后训练集类别分布:", Counter(y_smoteenn))
10. # 训练模型
11. model_smoteenn = LogisticRegression(random_state=42)
12. model_smoteenn.fit(X_smoteenn, y_smoteenn)
14. # 预测并评估
15. y_pred_smoteenn = model_smoteenn.predict(X_test)
16. print("\n使用SMOTEENN的分类报告:\n", classification_report(y_test, y_pred_smoteenn))

复制代码

SMOTETomek首先应用SMOTE进行过采样，然后应用Tomek Links进行欠采样。

2. from imblearn.combine import SMOTETomek
4. # 应用SMOTETomek
5. smote_tomek = SMOTETomek(random_state=42)
6. X_smotetomek, y_smotetomek = smote_tomek.fit_resample(X_train, y_train)
8. print("SMOTETomek后训练集类别分布:", Counter(y_smotetomek))
10. # 训练模型
11. model_smotetomek = LogisticRegression(random_state=42)
12. model_smotetomek.fit(X_smotetomek, y_smotetomek)
14. # 预测并评估
15. y_pred_smotetomek = model_smotetomek.predict(X_test)
16. print("\n使用SMOTETomek的分类报告:\n", classification_report(y_test, y_pred_smotetomek))

复制代码

算法调整方法

除了数据重采样技术外，我们还可以通过调整算法本身来处理不平衡数据集。

类权重调整

许多Scikit-learn算法允许我们为不同类别设置不同的权重，使得模型在训练过程中更加关注少数类。

2. from sklearn.linear_model import LogisticRegression
3. from sklearn.svm import SVC
4. from sklearn.ensemble import RandomForestClassifier
5. from sklearn.metrics import classification_report
7. # 逻辑回归
8. model_lr = LogisticRegression(class_weight='balanced', random_state=42)
9. model_lr.fit(X_train, y_train)
10. y_pred_lr = model_lr.predict(X_test)
11. print("逻辑回归（平衡类权重）的分类报告:\n", classification_report(y_test, y_pred_lr))
13. # 支持向量机
14. model_svc = SVC(class_weight='balanced', random_state=42, probability=True)
15. model_svc.fit(X_train, y_train)
16. y_pred_svc = model_svc.predict(X_test)
17. print("\n支持向量机（平衡类权重）的分类报告:\n", classification_report(y_test, y_pred_svc))
19. # 随机森林
20. model_rf = RandomForestClassifier(class_weight='balanced', random_state=42)
21. model_rf.fit(X_train, y_train)
22. y_pred_rf = model_rf.predict(X_test)
23. print("\n随机森林（平衡类权重）的分类报告:\n", classification_report(y_test, y_pred_rf))

复制代码

2. # 计算自定义类权重
3. from sklearn.utils.class_weight import compute_class_weight
5. class_weights = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train)
6. class_weight_dict = dict(zip(np.unique(y_train), class_weights))
7. print("自定义类权重:", class_weight_dict)
9. # 使用自定义类权重
10. model_custom = LogisticRegression(class_weight=class_weight_dict, random_state=42)
11. model_custom.fit(X_train, y_train)
12. y_pred_custom = model_custom.predict(X_test)
13. print("\n逻辑回归（自定义类权重）的分类报告:\n", classification_report(y_test, y_pred_custom))

复制代码

专门设计用于不平衡数据集的算法

有些算法专门设计用于处理不平衡数据集，例如EasyEnsemble和BalanceCascade。

EasyEnsemble是一种集成学习方法，它从多数类中随机抽取多个子集，每个子集与少数类结合形成一个平衡的训练集，然后训练多个分类器并集成它们的预测结果。

2. from imblearn.ensemble import EasyEnsembleClassifier
4. # 应用EasyEnsemble
5. eec = EasyEnsembleClassifier(random_state=42)
6. eec.fit(X_train, y_train)
7. y_pred_eec = eec.predict(X_test)
8. print("EasyEnsemble的分类报告:\n", classification_report(y_test, y_pred_eec))

复制代码

BalanceCascade是一种级联方法，它训练一系列分类器，每个分类器专注于被前一个分类器错误分类的样本。

2. from imblearn.ensemble import BalanceCascadeClassifier
4. # 应用BalanceCascade
5. bcc = BalanceCascadeClassifier(random_state=42)
6. bcc.fit(X_train, y_train)
7. y_pred_bcc = bcc.predict(X_test)
8. print("BalanceCascade的分类报告:\n", classification_report(y_test, y_pred_bcc))

复制代码

集成学习方法

集成学习方法通过组合多个基学习器的预测结果来提高模型性能，在不平衡数据集上尤其有效。

1. Bagging

Bagging（Bootstrap Aggregating）通过对训练数据进行有放回抽样生成多个训练集，训练多个基学习器，然后通过投票或平均的方式集成预测结果。

2. from sklearn.ensemble import BaggingClassifier
3. from sklearn.tree import DecisionTreeClassifier
5. # 使用Bagging
6. base_estimator = DecisionTreeClassifier(class_weight='balanced', random_state=42)
7. bagging = BaggingClassifier(base_estimator=base_estimator, n_estimators=50, random_state=42)
8. bagging.fit(X_train, y_train)
9. y_pred_bagging = bagging.predict(X_test)
10. print("Bagging的分类报告:\n", classification_report(y_test, y_pred_bagging))

复制代码

2. Boosting

Boosting通过迭代训练一系列弱学习器，每个后续学习器专注于前一个学习器错误分类的样本。

2. from sklearn.ensemble import AdaBoostClassifier
4. # 使用AdaBoost
5. adaboost = AdaBoostClassifier(n_estimators=50, random_state=42)
6. adaboost.fit(X_train, y_train)
7. y_pred_adaboost = adaboost.predict(X_test)
8. print("AdaBoost的分类报告:\n", classification_report(y_test, y_pred_adaboost))

复制代码

2. from sklearn.ensemble import GradientBoostingClassifier
4. # 使用Gradient Boosting
5. gb = GradientBoostingClassifier(n_estimators=50, random_state=42)
6. gb.fit(X_train, y_train)
7. y_pred_gb = gb.predict(X_test)
8. print("Gradient Boosting的分类报告:\n", classification_report(y_test, y_pred_gb))

复制代码

3. BalancedRandomForest

BalancedRandomForest是随机森林的变体，它在构建每棵树时对 bootstrap 样本进行平衡，使得每个 bootstrap 样本中少数类和多数类的样本数量相等。

2. from imblearn.ensemble import BalancedRandomForestClassifier
4. # 使用BalancedRandomForest
5. brf = BalancedRandomForestClassifier(n_estimators=50, random_state=42)
6. brf.fit(X_train, y_train)
7. y_pred_brf = brf.predict(X_test)
8. print("BalancedRandomForest的分类报告:\n", classification_report(y_test, y_pred_brf))

复制代码

4. RUSBoost

RUSBoost结合了随机欠采样（RUS）和AdaBoost算法，在每个迭代中先对多数类进行欠采样，然后应用AdaBoost。

2. from imblearn.ensemble import RUSBoostClassifier
4. # 使用RUSBoost
5. rusboost = RUSBoostClassifier(n_estimators=50, random_state=42)
6. rusboost.fit(X_train, y_train)
7. y_pred_rusboost = rusboost.predict(X_test)
8. print("RUSBoost的分类报告:\n", classification_report(y_test, y_pred_rusboost))

复制代码

实际案例：使用Scikit-learn处理不平衡数据集的完整示例

让我们通过一个完整的实际案例，综合应用前面介绍的方法来处理不平衡数据集。

2. import numpy as np
3. import pandas as pd
4. import matplotlib.pyplot as plt
5. import seaborn as sns
6. from sklearn.datasets import make_classification
7. from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, GridSearchCV
8. from sklearn.preprocessing import StandardScaler
9. from sklearn.linear_model import LogisticRegression
10. from sklearn.svm import SVC
11. from sklearn.tree import DecisionTreeClassifier
12. from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
13. from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
14.                              roc_auc_score, average_precision_score, confusion_matrix,
15.                              classification_report, roc_curve, precision_recall_curve)
16. from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler
17. from imblearn.under_sampling import RandomUnderSampler, TomekLinks, NearMiss
18. from imblearn.combine import SMOTEENN, SMOTETomek
19. from imblearn.ensemble import EasyEnsembleClassifier, BalancedRandomForestClassifier, RUSBoostClassifier
20. import warnings
21. warnings.filterwarnings('ignore')
23. # 1. 创建不平衡数据集
24. X, y = make_classification(n_samples=10000, n_features=20, n_informative=15,
25.                           n_redundant=3, n_classes=2, weights=[0.95, 0.05],
26.                           flip_y=0.05, random_state=42)
28. # 2. 数据预处理
29. # 划分训练集和测试集
30. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
32. # 特征标准化
33. scaler = StandardScaler()
34. X_train_scaled = scaler.fit_transform(X_train)
35. X_test_scaled = scaler.transform(X_test)
37. # 3. 定义评估函数
38. def evaluate_model(model, X_test, y_test, model_name="Model"):
39.     """评估模型性能并打印指标"""
40.     y_pred = model.predict(X_test)
41.     y_pred_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None
42.    
43.     # 计算各项指标
44.     accuracy = accuracy_score(y_test, y_pred)
45.     precision = precision_score(y_test, y_pred)
46.     recall = recall_score(y_test, y_pred)
47.     f1 = f1_score(y_test, y_pred)
48.    
49.     print(f"{model_name} 评估结果:")
50.     print(f"准确率: {accuracy:.4f}")
51.     print(f"精确率: {precision:.4f}")
52.     print(f"召回率: {recall:.4f}")
53.     print(f"F1分数: {f1:.4f}")
54.    
55.     if y_pred_proba is not None:
56.         roc_auc = roc_auc_score(y_test, y_pred_proba)
57.         pr_auc = average_precision_score(y_test, y_pred_proba)
58.         print(f"ROC AUC: {roc_auc:.4f}")
59.         print(f"PR AUC: {pr_auc:.4f}")
60.    
61.     print("\n分类报告:")
62.     print(classification_report(y_test, y_pred))
63.    
64.     # 绘制混淆矩阵
65.     cm = confusion_matrix(y_test, y_pred)
66.     plt.figure(figsize=(8, 6))
67.     sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
68.                 xticklabels=['Negative', 'Positive'],
69.                 yticklabels=['Negative', 'Positive'])
70.     plt.title(f'{model_name} 混淆矩阵')
71.     plt.ylabel('真实标签')
72.     plt.xlabel('预测标签')
73.     plt.show()
74.    
75.     # 绘制ROC和PR曲线
76.     if y_pred_proba is not None:
77.         fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
78.         precision_curve, recall_curve, _ = precision_recall_curve(y_test, y_pred_proba)
79.         
80.         plt.figure(figsize=(12, 5))
81.         plt.subplot(1, 2, 1)
82.         plt.plot(fpr, tpr, label=f'ROC Curve (AUC = {roc_auc:.2f})')
83.         plt.plot([0, 1], [0, 1], 'k--')
84.         plt.xlabel('False Positive Rate')
85.         plt.ylabel('True Positive Rate')
86.         plt.title('ROC Curve')
87.         plt.legend()
88.         
89.         plt.subplot(1, 2, 2)
90.         plt.plot(recall_curve, precision_curve, label=f'PR Curve (AUC = {pr_auc:.2f})')
91.         plt.xlabel('Recall')
92.         plt.ylabel('Precision')
93.         plt.title('Precision-Recall Curve')
94.         plt.legend()
95.         
96.         plt.tight_layout()
97.         plt.show()
98.    
99.     return {
100.         'accuracy': accuracy,
101.         'precision': precision,
102.         'recall': recall,
103.         'f1': f1,
104.         'roc_auc': roc_auc if y_pred_proba is not None else None,
105.         'pr_auc': pr_auc if y_pred_proba is not None else None
106.     }
108. # 4. 基准模型（不处理不平衡）
109. print("="*50)
110. print("基准模型（不处理不平衡）")
111. print("="*50)
113. # 逻辑回归
114. lr = LogisticRegression(random_state=42)
115. lr.fit(X_train_scaled, y_train)
116. lr_metrics = evaluate_model(lr, X_test_scaled, y_test, "逻辑回归")
118. # 随机森林
119. rf = RandomForestClassifier(random_state=42)
120. rf.fit(X_train_scaled, y_train)
121. rf_metrics = evaluate_model(rf, X_test_scaled, y_test, "随机森林")
123. # 5. 数据重采样方法
124. print("="*50)
125. print("数据重采样方法")
126. print("="*50)
128. # 5.1 过采样方法
129. # SMOTE
130. smote = SMOTE(random_state=42)
131. X_train_smote, y_train_smote = smote.fit_resample(X_train_scaled, y_train)
132. lr_smote = LogisticRegression(random_state=42)
133. lr_smote.fit(X_train_smote, y_train_smote)
134. lr_smote_metrics = evaluate_model(lr_smote, X_test_scaled, y_test, "逻辑回归 + SMOTE")
136. # ADASYN
137. adasyn = ADASYN(random_state=42)
138. X_train_adasyn, y_train_adasyn = adasyn.fit_resample(X_train_scaled, y_train)
139. lr_adasyn = LogisticRegression(random_state=42)
140. lr_adasyn.fit(X_train_adasyn, y_train_adasyn)
141. lr_adasyn_metrics = evaluate_model(lr_adasyn, X_test_scaled, y_test, "逻辑回归 + ADASYN")
143. # 5.2 欠采样方法
144. # RandomUnderSampler
145. rus = RandomUnderSampler(random_state=42)
146. X_train_rus, y_train_rus = rus.fit_resample(X_train_scaled, y_train)
147. lr_rus = LogisticRegression(random_state=42)
148. lr_rus.fit(X_train_rus, y_train_rus)
149. lr_rus_metrics = evaluate_model(lr_rus, X_test_scaled, y_test, "逻辑回归 + 随机欠采样")
151. # TomekLinks
152. tl = TomekLinks()
153. X_train_tl, y_train_tl = tl.fit_resample(X_train_scaled, y_train)
154. lr_tl = LogisticRegression(random_state=42)
155. lr_tl.fit(X_train_tl, y_train_tl)
156. lr_tl_metrics = evaluate_model(lr_tl, X_test_scaled, y_test, "逻辑回归 + TomekLinks")
158. # 5.3 混合采样方法
159. # SMOTEENN
160. smoteenn = SMOTEENN(random_state=42)
161. X_train_smoteenn, y_train_smoteenn = smoteenn.fit_resample(X_train_scaled, y_train)
162. lr_smoteenn = LogisticRegression(random_state=42)
163. lr_smoteenn.fit(X_train_smoteenn, y_train_smoteenn)
164. lr_smoteenn_metrics = evaluate_model(lr_smoteenn, X_test_scaled, y_test, "逻辑回归 + SMOTEENN")
166. # SMOTETomek
167. smotetomek = SMOTETomek(random_state=42)
168. X_train_smotetomek, y_train_smotetomek = smotetomek.fit_resample(X_train_scaled, y_train)
169. lr_smotetomek = LogisticRegression(random_state=42)
170. lr_smotetomek.fit(X_train_smotetomek, y_train_smotetomek)
171. lr_smotetomek_metrics = evaluate_model(lr_smotetomek, X_test_scaled, y_test, "逻辑回归 + SMOTETomek")
173. # 6. 算法调整方法
174. print("="*50)
175. print("算法调整方法")
176. print("="*50)
178. # 6.1 类权重调整
179. # 逻辑回归 + 平衡类权重
180. lr_balanced = LogisticRegression(class_weight='balanced', random_state=42)
181. lr_balanced.fit(X_train_scaled, y_train)
182. lr_balanced_metrics = evaluate_model(lr_balanced, X_test_scaled, y_test, "逻辑回归 + 平衡类权重")
184. # 随机森林 + 平衡类权重
185. rf_balanced = RandomForestClassifier(class_weight='balanced', random_state=42)
186. rf_balanced.fit(X_train_scaled, y_train)
187. rf_balanced_metrics = evaluate_model(rf_balanced, X_test_scaled, y_test, "随机森林 + 平衡类权重")
189. # 6.2 专门设计用于不平衡数据集的算法
190. # EasyEnsemble
191. eec = EasyEnsembleClassifier(random_state=42)
192. eec.fit(X_train_scaled, y_train)
193. eec_metrics = evaluate_model(eec, X_test_scaled, y_test, "EasyEnsemble")
195. # BalancedRandomForest
196. brf = BalancedRandomForestClassifier(random_state=42)
197. brf.fit(X_train_scaled, y_train)
198. brf_metrics = evaluate_model(brf, X_test_scaled, y_test, "BalancedRandomForest")
200. # RUSBoost
201. rusboost = RUSBoostClassifier(random_state=42)
202. rusboost.fit(X_train_scaled, y_train)
203. rusboost_metrics = evaluate_model(rusboost, X_test_scaled, y_test, "RUSBoost")
205. # 7. 模型比较
206. print("="*50)
207. print("模型比较")
208. print("="*50)
210. # 收集所有模型的指标
211. all_metrics = {
212.     '逻辑回归': lr_metrics,
213.     '随机森林': rf_metrics,
214.     '逻辑回归 + SMOTE': lr_smote_metrics,
215.     '逻辑回归 + ADASYN': lr_adasyn_metrics,
216.     '逻辑回归 + 随机欠采样': lr_rus_metrics,
217.     '逻辑回归 + TomekLinks': lr_tl_metrics,
218.     '逻辑回归 + SMOTEENN': lr_smoteenn_metrics,
219.     '逻辑回归 + SMOTETomek': lr_smotetomek_metrics,
220.     '逻辑回归 + 平衡类权重': lr_balanced_metrics,
221.     '随机森林 + 平衡类权重': rf_balanced_metrics,
222.     'EasyEnsemble': eec_metrics,
223.     'BalancedRandomForest': brf_metrics,
224.     'RUSBoost': rusboost_metrics
225. }
227. # 创建比较表格
228. metrics_df = pd.DataFrame.from_dict(all_metrics, orient='index')
229. metrics_df = metrics_df.sort_values('f1', ascending=False)
230. print(metrics_df)
232. # 可视化比较
233. plt.figure(figsize=(15, 10))
234. metrics_to_plot = ['accuracy', 'precision', 'recall', 'f1', 'roc_auc', 'pr_auc']
235. for i, metric in enumerate(metrics_to_plot, 1):
236.     plt.subplot(2, 3, i)
237.     sns.barplot(x=metrics_df.index, y=metrics_df[metric])
238.     plt.title(metric.upper())
239.     plt.xticks(rotation=90)
240.     plt.ylim(0, 1)
241. plt.tight_layout()
242. plt.show()
244. # 8. 最佳模型调优
245. print("="*50)
246. print("最佳模型调优")
247. print("="*50)
249. # 假设BalancedRandomForest表现最好，我们对其进行调优
250. param_grid = {
251.     'n_estimators': [50, 100, 200],
252.     'max_depth': [None, 10, 20, 30],
253.     'min_samples_split': [2, 5, 10],
254.     'min_samples_leaf': [1, 2, 4]
255. }
257. cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
258. grid_search = GridSearchCV(
259.     estimator=BalancedRandomForestClassifier(random_state=42),
260.     param_grid=param_grid,
261.     scoring='f1',
262.     cv=cv,
263.     n_jobs=-1,
264.     verbose=1
265. )
267. grid_search.fit(X_train_scaled, y_train)
269. print("最佳参数:", grid_search.best_params_)
270. print("最佳F1分数:", grid_search.best_score_)
272. # 使用最佳参数的模型
273. best_model = grid_search.best_estimator_
274. best_metrics = evaluate_model(best_model, X_test_scaled, y_test, "调优后的BalancedRandomForest")
276. # 9. 结论
277. print("="*50)
278. print("结论")
279. print("="*50)
280. print("在这个不平衡数据集的案例中，我们比较了多种处理不平衡数据集的方法，包括：")
281. print("1. 数据重采样技术（过采样、欠采样和混合采样）")
282. print("2. 算法调整方法（类权重调整和专门设计的算法）")
283. print("\n通过比较不同方法的性能指标，我们发现BalancedRandomForest在这个数据集上表现最好。")
284. print("经过参数调优后，模型的性能得到了进一步提升。")
285. print("\n在实际应用中，应该根据具体的数据集特点和业务需求选择合适的方法。")
286. print("通常，结合多种方法可能会获得更好的效果。")

复制代码

最佳实践和策略选择

在处理不平衡数据集时，没有一种方法适用于所有情况。以下是一些最佳实践和策略选择的建议：

1. 理解数据和业务需求

在选择处理不平衡数据集的方法之前，首先要理解数据和业务需求：

• 不平衡程度：数据集的不平衡程度如何？是轻微不平衡（如4:1）还是严重不平衡（如1000:1）？
• 样本数量：数据集的总样本量是多少？如果样本量很少，欠采样可能会导致信息丢失。
• 特征维度：特征维度高还是低？高维数据可能需要不同的处理方法。
• 业务目标：业务更关注精确率还是召回率？例如，在疾病诊断中，可能更关注召回率（不漏诊），而在垃圾邮件过滤中，可能更关注精确率（不误判正常邮件）。

2. 评估指标选择

根据业务需求选择合适的评估指标：

• 如果两类都重要，使用F1分数或G-Mean（几何平均数）。
• 如果更关注少数类的识别，使用召回率。
• 如果更关注预测的准确性，使用精确率。
• 如果需要综合考虑，使用ROC AUC或PR AUC。

3. 策略选择指南

根据不同情况选择合适的策略：

• 推荐方法：欠采样或混合采样
• 理由：数据量大，欠采样不会导致严重信息丢失，同时可以减少训练时间
• 具体技术：RandomUnderSampler、TomekLinks、SMOTETomek

• 推荐方法：过采样或类权重调整
• 理由：数据量小，欠采样会导致信息丢失，过采样可以增加少数类样本
• 具体技术：SMOTE、ADASYN、类权重调整

• 推荐方法：混合采样或专门设计的算法
• 理由：结合过采样和欠采样的优点，或使用专门处理不平衡数据的算法
• 具体技术：SMOTEENN、SMOTETomek、BalancedRandomForest、RUSBoost

• 推荐方法：类权重调整或简单采样方法
• 理由：复杂的采样方法或集成方法可能会降低模型的可解释性
• 具体技术：类权重调整、RandomOverSampler、RandomUnderSampler

4. 组合策略

在某些情况下，组合多种策略可能会获得更好的效果：

• 数据重采样 + 类权重调整：先对数据进行重采样，然后在训练模型时使用类权重调整。
• 数据重采样 + 集成学习：使用重采样技术创建多个平衡的训练集，然后训练多个基学习器并集成。
• 特征选择 + 数据重采样：先进行特征选择，然后对数据进行重采样。

5. 验证策略

在不平衡数据集上，使用合适的验证策略非常重要：

• 分层K折交叉验证：确保每折中各类别的比例与原始数据集相同。
• 重复分层K折交叉验证：多次运行分层K折交叉验证，获得更稳定的评估结果。
• 自定义验证集：确保验证集的不平衡程度与测试集相似。

6. 实际应用中的注意事项

在实际应用中，还需要注意以下几点：

• 数据泄露：确保在数据重采样之前划分训练集和测试集，避免测试集信息泄露到训练过程。
• 计算成本：某些方法（如SMOTE在大数据集上）可能计算成本较高，需要考虑实际应用场景的计算资源限制。
• 模型复杂度：在不平衡数据集上，简单的模型可能比复杂的模型表现更好，因为复杂模型更容易过拟合多数类。
• 阈值调整：除了上述方法外，还可以通过调整预测阈值来优化模型性能。例如，降低预测少数类的阈值可以提高召回率。

结论

处理不平衡数据集是机器学习中的一个常见挑战，Scikit-learn和imbalanced-learn库提供了丰富的工具和方法来应对这一挑战。本文全面介绍了从数据重采样到算法调整的各种策略，并通过实际案例展示了如何应用这些方法。

关键要点总结：

1. 评估指标选择：在不平衡数据集上，准确率往往不是合适的评估指标，应选择精确率、召回率、F1分数、ROC AUC或PR AUC等指标。
2. 数据重采样技术：过采样（如SMOTE、ADASYN）通过增加少数类样本来平衡数据集。欠采样（如RandomUnderSampler、TomekLinks）通过减少多数类样本来平衡数据集。混合采样（如SMOTEENN、SMOTETomek）结合了过采样和欠采样的优点。
3. 过采样（如SMOTE、ADASYN）通过增加少数类样本来平衡数据集。
4. 欠采样（如RandomUnderSampler、TomekLinks）通过减少多数类样本来平衡数据集。
5. 混合采样（如SMOTEENN、SMOTETomek）结合了过采样和欠采样的优点。
6. 算法调整方法：类权重调整（如设置class_weight=‘balanced’）使模型在训练过程中更加关注少数类。专门设计用于不平衡数据集的算法（如EasyEnsemble、BalancedRandomForest、RUSBoost）。
7. 类权重调整（如设置class_weight=‘balanced’）使模型在训练过程中更加关注少数类。
8. 专门设计用于不平衡数据集的算法（如EasyEnsemble、BalancedRandomForest、RUSBoost）。
9. 策略选择：根据数据集特点（不平衡程度、样本数量、特征维度）和业务需求选择合适的策略。
10. 组合策略：在某些情况下，组合多种策略可能会获得更好的效果。
11. 验证策略：使用分层K折交叉验证等合适的验证策略，确保评估结果的可靠性。

评估指标选择：在不平衡数据集上，准确率往往不是合适的评估指标，应选择精确率、召回率、F1分数、ROC AUC或PR AUC等指标。

数据重采样技术：

• 过采样（如SMOTE、ADASYN）通过增加少数类样本来平衡数据集。
• 欠采样（如RandomUnderSampler、TomekLinks）通过减少多数类样本来平衡数据集。
• 混合采样（如SMOTEENN、SMOTETomek）结合了过采样和欠采样的优点。

算法调整方法：

• 类权重调整（如设置class_weight=‘balanced’）使模型在训练过程中更加关注少数类。
• 专门设计用于不平衡数据集的算法（如EasyEnsemble、BalancedRandomForest、RUSBoost）。

策略选择：根据数据集特点（不平衡程度、样本数量、特征维度）和业务需求选择合适的策略。

组合策略：在某些情况下，组合多种策略可能会获得更好的效果。

验证策略：使用分层K折交叉验证等合适的验证策略，确保评估结果的可靠性。

在实际应用中，处理不平衡数据集往往需要尝试多种方法，并根据具体情况进行调整。通过本文介绍的方法和策略，读者可以更好地应对不平衡数据集带来的挑战，提高机器学习模型在不平衡数据上的性能。

版权声明

1、转载或引用本网站内容(掌握Scikit-learn处理不平衡数据集的核心策略从数据重采样到算法调整全面解决机器学习模型性能问题)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-36778-1-1.html