scikit-learn模型评估与预测实战指南从基础指标到高级技巧全面掌握机器学习核心技能

威震华夏关云长

引言

在机器学习项目中，模型评估与预测是至关重要的环节。它们帮助我们了解模型的性能、选择最佳模型、调整超参数以及最终将模型应用于实际场景。scikit-learn作为Python中最流行的机器学习库之一，提供了丰富的工具和函数来支持模型评估与预测的全过程。本文将带你从基础指标到高级技巧，全面掌握使用scikit-learn进行模型评估与预测的核心技能。

1. 基础评估指标

1.1 分类问题评估指标

准确率是最直观的分类评估指标，表示正确预测的样本数占总样本数的比例。

2. from sklearn.metrics import accuracy_score
3. from sklearn.datasets import make_classification
4. from sklearn.model_selection import train_test_split
5. from sklearn.linear_model import LogisticRegression
7. # 生成模拟数据
8. X, y = make_classification(n_samples=1000, n_classes=2, random_state=42)
9. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
11. # 训练模型
12. model = LogisticRegression()
13. model.fit(X_train, y_train)
15. # 预测
16. y_pred = model.predict(X_test)
18. # 计算准确率
19. accuracy = accuracy_score(y_test, y_pred)
20. print(f"准确率: {accuracy:.4f}")

复制代码

精确率是指被正确预测为正例的样本数占所有被预测为正例的样本数的比例。召回率是指被正确预测为正例的样本数占所有实际为正例的样本数的比例。

2. from sklearn.metrics import precision_score, recall_score
4. # 计算精确率和召回率
5. precision = precision_score(y_test, y_pred)
6. recall = recall_score(y_test, y_pred)
8. print(f"精确率: {precision:.4f}")
9. print(f"召回率: {recall:.4f}")

复制代码

F1分数是精确率和召回率的调和平均值，是综合评估模型性能的指标。

2. from sklearn.metrics import f1_score
4. # 计算F1分数
5. f1 = f1_score(y_test, y_pred)
6. print(f"F1分数: {f1:.4f}")

复制代码

scikit-learn提供了classification_report函数，可以一次性输出多个分类指标。

2. from sklearn.metrics import classification_report
4. # 生成分类报告
5. report = classification_report(y_test, y_pred)
6. print("分类报告:")
7. print(report)

复制代码

1.2 回归问题评估指标

MAE是预测值与真实值之差的绝对值的平均值。

2. from sklearn.datasets import make_regression
3. from sklearn.linear_model import LinearRegression
4. from sklearn.metrics import mean_absolute_error
6. # 生成模拟数据
7. X, y = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
8. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
10. # 训练模型
11. model = LinearRegression()
12. model.fit(X_train, y_train)
14. # 预测
15. y_pred = model.predict(X_test)
17. # 计算MAE
18. mae = mean_absolute_error(y_test, y_pred)
19. print(f"平均绝对误差 (MAE): {mae:.4f}")

复制代码

MSE是预测值与真实值之差的平方的平均值，RMSE是MSE的平方根。

2. from sklearn.metrics import mean_squared_error
4. # 计算MSE
5. mse = mean_squared_error(y_test, y_pred)
6. print(f"均方误差 (MSE): {mse:.4f}")
8. # 计算RMSE
9. rmse = mean_squared_error(y_test, y_pred, squared=False)
10. print(f"均方根误差 (RMSE): {rmse:.4f}")

复制代码

R²分数表示模型对数据方差的解释程度，范围通常在0到1之间，越接近1表示模型拟合效果越好。

2. from sklearn.metrics import r2_score
4. # 计算R²分数
5. r2 = r2_score(y_test, y_pred)
6. print(f"决定系数 (R²): {r2:.4f}")

复制代码

2. 高级评估指标与技术

2.1 混淆矩阵 (Confusion Matrix)

混淆矩阵提供了更详细的分类结果展示，包括真正例(TP)、假正例(FP)、假反例(FN)和真反例(TN)。

2. import matplotlib.pyplot as plt
3. from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
5. # 计算混淆矩阵
6. cm = confusion_matrix(y_test, y_pred)
8. # 可视化混淆矩阵
9. disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=model.classes_)
10. disp.plot(cmap=plt.cm.Blues)
11. plt.title('混淆矩阵')
12. plt.show()

复制代码

2.2 ROC曲线和AUC值

ROC曲线展示了在不同阈值下模型的真正例率(TPR)和假正例率(FPR)之间的关系，AUC值表示ROC曲线下的面积，用于评估模型的整体性能。

2. from sklearn.metrics import roc_curve, auc, RocCurveDisplay
4. # 获取预测概率
5. y_prob = model.predict_proba(X_test)[:, 1]
7. # 计算ROC曲线
8. fpr, tpr, thresholds = roc_curve(y_test, y_prob)
9. roc_auc = auc(fpr, tpr)
11. # 可视化ROC曲线
12. display = RocCurveDisplay(fpr=fpr, tpr=tpr, roc_auc=roc_auc, estimator_name='Logistic Regression')
13. display.plot()
14. plt.title('ROC曲线')
15. plt.show()
17. print(f"AUC值: {roc_auc:.4f}")

复制代码

2.3 精确率-召回率曲线

精确率-召回率曲线展示了精确率和召回率之间的权衡关系，特别适用于类别不平衡的数据集。

2. from sklearn.metrics import precision_recall_curve, average_precision_score, PrecisionRecallDisplay
4. # 计算精确率-召回率曲线
5. precision, recall, _ = precision_recall_curve(y_test, y_prob)
6. average_precision = average_precision_score(y_test, y_prob)
8. # 可视化精确率-召回率曲线
9. display = PrecisionRecallDisplay(precision=precision, recall=recall, average_precision=average_precision)
10. display.plot()
11. plt.title('精确率-召回率曲线')
12. plt.show()
14. print(f"平均精确率: {average_precision:.4f}")

复制代码

2.4 学习曲线 (Learning Curve)

学习曲线展示了模型性能随训练集大小变化的情况，有助于判断模型是否过拟合或欠拟合。

2. import numpy as np
3. from sklearn.model_selection import learning_curve
5. def plot_learning_curve(estimator, title, X, y, cv=None, n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):
6.     plt.figure()
7.     plt.title(title)
8.     plt.xlabel("训练样本数")
9.     plt.ylabel("得分")
10.    
11.     train_sizes, train_scores, test_scores = learning_curve(
12.         estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
13.    
14.     train_scores_mean = np.mean(train_scores, axis=1)
15.     train_scores_std = np.std(train_scores, axis=1)
16.     test_scores_mean = np.mean(test_scores, axis=1)
17.     test_scores_std = np.std(test_scores, axis=1)
18.    
19.     plt.grid()
20.    
21.     plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
22.                      train_scores_mean + train_scores_std, alpha=0.1,
23.                      color="r")
24.     plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
25.                      test_scores_mean + test_scores_std, alpha=0.1, color="g")
26.     plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
27.              label="训练集得分")
28.     plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
29.              label="交叉验证集得分")
30.    
31.     plt.legend(loc="best")
32.     return plt
34. # 绘制学习曲线
35. plot_learning_curve(model, "学习曲线 (Logistic Regression)", X, y, cv=5)
36. plt.show()

复制代码

2.5 验证曲线 (Validation Curve)

验证曲线展示了模型性能随超参数变化的情况，有助于选择最佳超参数值。

2. from sklearn.model_selection import validation_curve
4. def plot_validation_curve(estimator, title, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=None):
5.     train_scores, test_scores = validation_curve(
6.         estimator, X, y, param_name=param_name, param_range=param_range,
7.         cv=cv, scoring=scoring, n_jobs=n_jobs)
8.    
9.     train_scores_mean = np.mean(train_scores, axis=1)
10.     train_scores_std = np.std(train_scores, axis=1)
11.     test_scores_mean = np.mean(test_scores, axis=1)
12.     test_scores_std = np.std(test_scores, axis=1)
13.    
14.     plt.title(title)
15.     plt.xlabel(param_name)
16.     plt.ylabel("得分")
17.     plt.ylim(0.0, 1.1)
18.     lw = 2
19.     plt.plot(param_range, train_scores_mean, label="训练集得分", color="darkorange", lw=lw)
20.     plt.fill_between(param_range, train_scores_mean - train_scores_std,
21.                      train_scores_mean + train_scores_std, alpha=0.2,
22.                      color="darkorange", lw=lw)
23.     plt.plot(param_range, test_scores_mean, label="交叉验证集得分", color="navy", lw=lw)
24.     plt.fill_between(param_range, test_scores_mean - test_scores_std,
25.                      test_scores_mean + test_scores_std, alpha=0.2,
26.                      color="navy", lw=lw)
27.     plt.legend(loc="best")
28.     return plt
30. # 绘制验证曲线
31. param_range = np.logspace(-3, 3, 7)
32. plot_validation_curve(model, "验证曲线 (Logistic Regression)", X, y,
33.                      param_name="C", param_range=param_range, cv=5)
34. plt.xscale('log')
35. plt.show()

复制代码

3. 交叉验证技术

3.1 K折交叉验证 (K-Fold Cross-Validation)

K折交叉验证将数据集分成K个子集，每次使用K-1个子集进行训练，剩余1个子集进行验证，重复K次。

2. from sklearn.model_selection import cross_val_score
4. # 执行5折交叉验证
5. cv_scores = cross_val_score(model, X, y, cv=5)
6. print(f"交叉验证得分: {cv_scores}")
7. print(f"平均交叉验证得分: {cv_scores.mean():.4f}")
8. print(f"交叉验证得分标准差: {cv_scores.std():.4f}")

复制代码

3.2 分层K折交叉验证 (Stratified K-Fold Cross-Validation)

分层K折交叉验证确保每个折中各类别的比例与整个数据集中的比例相同，特别适用于类别不平衡的数据集。

2. from sklearn.model_selection import StratifiedKFold
4. # 创建分层K折交叉验证对象
5. stratified_kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
7. # 执行分层K折交叉验证
8. stratified_cv_scores = cross_val_score(model, X, y, cv=stratified_kfold)
9. print(f"分层交叉验证得分: {stratified_cv_scores}")
10. print(f"平均分层交叉验证得分: {stratified_cv_scores.mean():.4f}")
11. print(f"分层交叉验证得分标准差: {stratified_cv_scores.std():.4f}")

复制代码

3.3 留一交叉验证 (Leave-One-Out Cross-Validation)

留一交叉验证是K折交叉验证的特例，其中K等于样本数，每次只留一个样本进行验证。

2. from sklearn.model_selection import LeaveOneOut
4. # 创建留一交叉验证对象
5. loo = LeaveOneOut()
7. # 执行留一交叉验证（注意：计算量较大，适合小数据集）
8. # loo_scores = cross_val_score(model, X, y, cv=loo)
9. # print(f"留一交叉验证平均得分: {loo_scores.mean():.4f}")

复制代码

3.4 时间序列交叉验证 (Time Series Split)

时间序列交叉验证专门用于时间序列数据，确保验证集始终在训练集之后。

2. from sklearn.model_selection import TimeSeriesSplit
4. # 创建时间序列交叉验证对象
5. tscv = TimeSeriesSplit(n_splits=5)
7. # 执行时间序列交叉验证
8. ts_scores = cross_val_score(model, X, y, cv=tscv)
9. print(f"时间序列交叉验证得分: {ts_scores}")
10. print(f"平均时间序列交叉验证得分: {ts_scores.mean():.4f}")

复制代码

4. 超参数调优

4.1 网格搜索 (Grid Search)

网格搜索通过遍历给定的超参数组合，找到最佳超参数。

2. from sklearn.model_selection import GridSearchCV
3. from sklearn.svm import SVC
5. # 定义参数网格
6. param_grid = {
7.     'C': [0.1, 1, 10, 100],
8.     'gamma': [1, 0.1, 0.01, 0.001],
9.     'kernel': ['rbf', 'linear']
10. }
12. # 创建SVC模型
13. svc = SVC(probability=True)
15. # 创建网格搜索对象
16. grid_search = GridSearchCV(estimator=svc, param_grid=param_grid, cv=5, verbose=2, n_jobs=-1)
18. # 执行网格搜索
19. grid_search.fit(X_train, y_train)
21. # 输出最佳参数和得分
22. print(f"最佳参数: {grid_search.best_params_}")
23. print(f"最佳交叉验证得分: {grid_search.best_score_:.4f}")
25. # 使用最佳模型进行预测
26. best_model = grid_search.best_estimator_
27. y_pred = best_model.predict(X_test)
28. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")

复制代码

4.2 随机搜索 (Random Search)

随机搜索在参数空间中随机采样一定数量的参数组合，通常比网格搜索更高效。

2. from sklearn.model_selection import RandomizedSearchCV
3. from scipy.stats import uniform, randint
5. # 定义参数分布
6. param_dist = {
7.     'C': uniform(0.1, 100),
8.     'gamma': uniform(0.001, 1),
9.     'kernel': ['rbf', 'linear']
10. }
12. # 创建随机搜索对象
13. random_search = RandomizedSearchCV(
14.     estimator=svc,
15.     param_distributions=param_dist,
16.     n_iter=20,
17.     cv=5,
18.     verbose=2,
19.     n_jobs=-1,
20.     random_state=42
21. )
23. # 执行随机搜索
24. random_search.fit(X_train, y_train)
26. # 输出最佳参数和得分
27. print(f"最佳参数: {random_search.best_params_}")
28. print(f"最佳交叉验证得分: {random_search.best_score_:.4f}")
30. # 使用最佳模型进行预测
31. best_model = random_search.best_estimator_
32. y_pred = best_model.predict(X_test)
33. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")

复制代码

4.3 贝叶斯优化 (Bayesian Optimization)

贝叶斯优化是一种更高级的超参数调优方法，它使用贝叶斯方法来选择下一个要评估的参数组合。

2. # 需要安装scikit-optimize: pip install scikit-optimize
3. from skopt import BayesSearchCV
4. from skopt.space import Real, Categorical, Integer
6. # 定义搜索空间
7. search_spaces = {
8.     'C': Real(0.1, 100, prior='log-uniform'),
9.     'gamma': Real(0.001, 1, prior='log-uniform'),
10.     'kernel': Categorical(['rbf', 'linear'])
11. }
13. # 创建贝叶斯优化对象
14. bayes_search = BayesSearchCV(
15.     estimator=svc,
16.     search_spaces=search_spaces,
17.     n_iter=20,
18.     cv=5,
19.     verbose=2,
20.     n_jobs=-1,
21.     random_state=42
22. )
24. # 执行贝叶斯优化
25. bayes_search.fit(X_train, y_train)
27. # 输出最佳参数和得分
28. print(f"最佳参数: {bayes_search.best_params_}")
29. print(f"最佳交叉验证得分: {bayes_search.best_score_:.4f}")
31. # 使用最佳模型进行预测
32. best_model = bayes_search.best_estimator_
33. y_pred = best_model.predict(X_test)
34. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")

复制代码

5. 模型预测技术

5.1 分类模型预测

2. from sklearn.ensemble import RandomForestClassifier
4. # 训练随机森林分类器
5. rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
6. rf_classifier.fit(X_train, y_train)
8. # 基本预测
9. y_pred = rf_classifier.predict(X_test)
10. print(f"前5个预测结果: {y_pred[:5]}")

复制代码

2. # 预测概率
3. y_prob = rf_classifier.predict_proba(X_test)
4. print(f"前5个样本的类别概率:\n{y_prob[:5]}")
6. # 获取正类的概率
7. y_prob_positive = y_prob[:, 1]
8. print(f"前5个样本的正类概率: {y_prob_positive[:5]}")

复制代码

2. # 预测决策函数值（适用于支持决策函数的模型，如SVM）
3. if hasattr(rf_classifier, 'decision_function'):
4.     y_decision = rf_classifier.decision_function(X_test)
5.     print(f"前5个样本的决策函数值: {y_decision[:5]}")

复制代码

5.2 回归模型预测

2. from sklearn.ensemble import RandomForestRegressor
4. # 训练随机森林回归器
5. rf_regressor = RandomForestRegressor(n_estimators=100, random_state=42)
6. rf_regressor.fit(X_train, y_train)
8. # 预测
9. y_pred = rf_regressor.predict(X_test)
10. print(f"前5个预测结果: {y_pred[:5]}")
11. print(f"前5个真实值: {y_test[:5]}")

复制代码

5.3 聚类模型预测

2. from sklearn.cluster import KMeans
3. from sklearn.datasets import make_blobs
5. # 生成聚类数据
6. X_blob, y_blob = make_blobs(n_samples=300, centers=4, random_state=42)
8. # 训练KMeans聚类模型
9. kmeans = KMeans(n_clusters=4, random_state=42)
10. kmeans.fit(X_blob)
12. # 预测簇标签
13. y_cluster = kmeans.predict(X_blob)
14. print(f"前5个样本的簇标签: {y_cluster[:5]}")
16. # 获取簇中心
17. centers = kmeans.cluster_centers_
18. print(f"簇中心坐标:\n{centers}")

复制代码

6. 模型持久化

6.1 使用pickle保存和加载模型

2. import pickle
4. # 保存模型到文件
5. with open('model.pkl', 'wb') as file:
6.     pickle.dump(rf_classifier, file)
8. # 从文件加载模型
9. with open('model.pkl', 'rb') as file:
10.     loaded_model = pickle.load(file)
12. # 使用加载的模型进行预测
13. y_pred_loaded = loaded_model.predict(X_test)
14. print(f"使用加载模型的前5个预测结果: {y_pred_loaded[:5]}")

复制代码

6.2 使用joblib保存和加载模型

2. from joblib import dump, load
4. # 保存模型到文件
5. dump(rf_classifier, 'model.joblib')
7. # 从文件加载模型
8. loaded_model = load('model.joblib')
10. # 使用加载的模型进行预测
11. y_pred_loaded = loaded_model.predict(X_test)
12. print(f"使用加载模型的前5个预测结果: {y_pred_loaded[:5]}")

复制代码

7. 实战案例：使用真实数据集进行模型评估与预测

7.1 数据准备与探索

2. import pandas as pd
3. from sklearn.datasets import load_breast_cancer
5. # 加载乳腺癌数据集
6. cancer = load_breast_cancer()
7. X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
8. y = pd.Series(cancer.target)
10. # 查看数据基本信息
11. print(f"数据形状: {X.shape}")
12. print(f"特征名称: {X.columns.tolist()}")
13. print(f"目标类别: {cancer.target_names}")
14. print(f"类别分布:\n{y.value_counts()}")
16. # 查看数据统计信息
17. print("\n数据统计信息:")
18. print(X.describe())
20. # 划分训练集和测试集
21. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

复制代码

7.2 数据预处理

2. from sklearn.preprocessing import StandardScaler
3. from sklearn.pipeline import Pipeline
5. # 创建预处理管道
6. preprocessor = Pipeline([
7.     ('scaler', StandardScaler())
8. ])
10. # 预处理训练数据
11. X_train_processed = preprocessor.fit_transform(X_train)
13. # 预处理测试数据
14. X_test_processed = preprocessor.transform(X_test)

复制代码

7.3 模型训练与评估

2. from sklearn.ensemble import RandomForestClassifier
3. from sklearn.svm import SVC
4. from sklearn.linear_model import LogisticRegression
6. # 定义多个模型
7. models = {
8.     'Logistic Regression': LogisticRegression(max_iter=10000, random_state=42),
9.     'SVM': SVC(probability=True, random_state=42),
10.     'Random Forest': RandomForestClassifier(random_state=42)
11. }
13. # 训练和评估每个模型
14. results = {}
15. for name, model in models.items():
16.     # 训练模型
17.     model.fit(X_train_processed, y_train)
18.    
19.     # 预测
20.     y_pred = model.predict(X_test_processed)
21.     y_prob = model.predict_proba(X_test_processed)[:, 1] if hasattr(model, 'predict_proba') else None
22.    
23.     # 评估模型
24.     accuracy = accuracy_score(y_test, y_pred)
25.     precision = precision_score(y_test, y_pred)
26.     recall = recall_score(y_test, y_pred)
27.     f1 = f1_score(y_test, y_pred)
28.    
29.     # 计算AUC（如果模型支持概率预测）
30.     if y_prob is not None:
31.         fpr, tpr, _ = roc_curve(y_test, y_prob)
32.         roc_auc = auc(fpr, tpr)
33.     else:
34.         roc_auc = None
35.    
36.     # 存储结果
37.     results[name] = {
38.         'accuracy': accuracy,
39.         'precision': precision,
40.         'recall': recall,
41.         'f1': f1,
42.         'roc_auc': roc_auc
43.     }
44.    
45.     # 打印结果
46.     print(f"\n{name} 评估结果:")
47.     print(f"准确率: {accuracy:.4f}")
48.     print(f"精确率: {precision:.4f}")
49.     print(f"召回率: {recall:.4f}")
50.     print(f"F1分数: {f1:.4f}")
51.     if roc_auc is not None:
52.         print(f"AUC: {roc_auc:.4f}")
53.    
54.     # 打印分类报告
55.     print("\n分类报告:")
56.     print(classification_report(y_test, y_pred))

复制代码

7.4 模型比较与可视化

2. import matplotlib.pyplot as plt
3. import numpy as np
5. # 准备比较数据
6. metrics = ['accuracy', 'precision', 'recall', 'f1']
7. model_names = list(results.keys())
9. # 创建条形图
10. x = np.arange(len(metrics))
11. width = 0.25
13. fig, ax = plt.subplots(figsize=(12, 6))
15. for i, model in enumerate(model_names):
16.     values = [results[model][metric] for metric in metrics]
17.     ax.bar(x + i * width, values, width, label=model)
19. # 添加标签和标题
20. ax.set_xlabel('评估指标')
21. ax.set_ylabel('分数')
22. ax.set_title('模型性能比较')
23. ax.set_xticks(x + width)
24. ax.set_xticklabels(metrics)
25. ax.legend()
27. plt.tight_layout()
28. plt.show()
30. # 绘制ROC曲线
31. plt.figure(figsize=(10, 8))
33. for name, model in models.items():
34.     if hasattr(model, 'predict_proba'):
35.         y_prob = model.predict_proba(X_test_processed)[:, 1]
36.         fpr, tpr, _ = roc_curve(y_test, y_prob)
37.         roc_auc = auc(fpr, tpr)
38.         plt.plot(fpr, tpr, label=f'{name} (AUC = {roc_auc:.2f})')
40. plt.plot([0, 1], [0, 1], 'k--')
41. plt.xlim([0.0, 1.0])
42. plt.ylim([0.0, 1.05])
43. plt.xlabel('假正例率')
44. plt.ylabel('真正例率')
45. plt.title('ROC曲线比较')
46. plt.legend(loc="lower right")
47. plt.show()

复制代码

7.5 超参数调优

2. # 选择最佳模型进行超参数调优
3. best_model_name = max(results.keys(), key=lambda k: results[k]['f1'])
4. print(f"选择 {best_model_name} 进行超参数调优")
6. if best_model_name == 'Logistic Regression':
7.     model = LogisticRegression(max_iter=10000, random_state=42)
8.     param_grid = {
9.         'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
10.         'penalty': ['l1', 'l2'],
11.         'solver': ['liblinear', 'saga']
12.     }
13. elif best_model_name == 'SVM':
14.     model = SVC(probability=True, random_state=42)
15.     param_grid = {
16.         'C': [0.1, 1, 10, 100],
17.         'gamma': [1, 0.1, 0.01, 0.001],
18.         'kernel': ['rbf', 'linear']
19.     }
20. else:  # Random Forest
21.     model = RandomForestClassifier(random_state=42)
22.     param_grid = {
23.         'n_estimators': [50, 100, 200],
24.         'max_depth': [None, 10, 20, 30],
25.         'min_samples_split': [2, 5, 10],
26.         'min_samples_leaf': [1, 2, 4]
27.     }
29. # 创建网格搜索对象
30. grid_search = GridSearchCV(
31.     estimator=model,
32.     param_grid=param_grid,
33.     cv=5,
34.     scoring='f1',
35.     verbose=1,
36.     n_jobs=-1
37. )
39. # 执行网格搜索
40. grid_search.fit(X_train_processed, y_train)
42. # 输出最佳参数和得分
43. print(f"\n最佳参数: {grid_search.best_params_}")
44. print(f"最佳交叉验证F1分数: {grid_search.best_score_:.4f}")
46. # 使用最佳模型进行预测
47. best_model = grid_search.best_estimator_
48. y_pred = best_model.predict(X_test_processed)
49. y_prob = best_model.predict_proba(X_test_processed)[:, 1] if hasattr(best_model, 'predict_proba') else None
51. # 评估最佳模型
52. accuracy = accuracy_score(y_test, y_pred)
53. precision = precision_score(y_test, y_pred)
54. recall = recall_score(y_test, y_pred)
55. f1 = f1_score(y_test, y_pred)
57. if y_prob is not None:
58.     fpr, tpr, _ = roc_curve(y_test, y_prob)
59.     roc_auc = auc(fpr, tpr)
60. else:
61.     roc_auc = None
63. print(f"\n调优后模型评估结果:")
64. print(f"准确率: {accuracy:.4f}")
65. print(f"精确率: {precision:.4f}")
66. print(f"召回率: {recall:.4f}")
67. print(f"F1分数: {f1:.4f}")
68. if roc_auc is not None:
69.     print(f"AUC: {roc_auc:.4f}")
71. # 打印分类报告
72. print("\n分类报告:")
73. print(classification_report(y_test, y_pred))

复制代码

7.6 特征重要性分析

2. # 如果模型支持特征重要性，则进行分析
3. if hasattr(best_model, 'feature_importances_'):
4.     # 获取特征重要性
5.     importances = best_model.feature_importances_
6.    
7.     # 创建特征重要性DataFrame
8.     feature_importance = pd.DataFrame({
9.         'feature': X.columns,
10.         'importance': importances
11.     }).sort_values('importance', ascending=False)
12.    
13.     # 打印前10个最重要的特征
14.     print("前10个最重要的特征:")
15.     print(feature_importance.head(10))
16.    
17.     # 可视化特征重要性
18.     plt.figure(figsize=(12, 8))
19.     plt.barh(feature_importance['feature'][:10], feature_importance['importance'][:10])
20.     plt.xlabel('重要性')
21.     plt.ylabel('特征')
22.     plt.title('特征重要性')
23.     plt.gca().invert_yaxis()
24.     plt.show()
26. elif hasattr(best_model, 'coef_'):
27.     # 对于线性模型，使用系数的绝对值作为特征重要性
28.     if len(best_model.coef_.shape) == 1:
29.         coefficients = best_model.coef_
30.     else:
31.         coefficients = best_model.coef_[0]
32.    
33.     # 创建特征重要性DataFrame
34.     feature_importance = pd.DataFrame({
35.         'feature': X.columns,
36.         'importance': np.abs(coefficients)
37.     }).sort_values('importance', ascending=False)
38.    
39.     # 打印前10个最重要的特征
40.     print("前10个最重要的特征:")
41.     print(feature_importance.head(10))
42.    
43.     # 可视化特征重要性
44.     plt.figure(figsize=(12, 8))
45.     plt.barh(feature_importance['feature'][:10], feature_importance['importance'][:10])
46.     plt.xlabel('系数绝对值')
47.     plt.ylabel('特征')
48.     plt.title('特征重要性')
49.     plt.gca().invert_yaxis()
50.     plt.show()

复制代码

8. 最佳实践和常见陷阱

8.1 数据泄露 (Data Leakage)

数据泄露是指测试集的信息在训练过程中被使用，导致模型评估过于乐观。

2. # 错误示例：在划分数据集之前进行标准化
3. X_wrong = StandardScaler().fit_transform(X)  # 错误：使用整个数据集进行拟合
4. X_train_wrong, X_test_wrong, y_train, y_test = train_test_split(X_wrong, y, test_size=0.2, random_state=42)
6. # 正确示例：先划分数据集，然后分别对训练集和测试集进行标准化
7. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
8. scaler = StandardScaler()
9. X_train_correct = scaler.fit_transform(X_train)  # 正确：只使用训练集进行拟合
10. X_test_correct = scaler.transform(X_test)  # 正确：使用相同的变换应用于测试集

复制代码

8.2 类别不平衡处理

类别不平衡会导致模型偏向多数类，影响模型性能。

2. from imblearn.over_sampling import SMOTE
3. from imblearn.under_sampling import RandomUnderSampler
4. from imblearn.pipeline import Pipeline as ImbPipeline
6. # 创建不平衡数据集
7. X_imb, y_imb = make_classification(n_samples=1000, n_classes=2, weights=[0.9, 0.1], random_state=42)
9. # 查看类别分布
10. print(f"原始数据类别分布: {pd.Series(y_imb).value_counts().to_dict()}")
12. # 方法1：使用class_weight参数
13. model_balanced = LogisticRegression(class_weight='balanced', random_state=42)
14. model_balanced.fit(X_imb, y_imb)
16. # 方法2：使用过采样和欠采样
17. resampling = ImbPipeline([
18.     ('oversample', SMOTE(random_state=42)),
19.     ('undersample', RandomUnderSampler(random_state=42)),
20.     ('classifier', LogisticRegression(random_state=42))
21. ])
23. resampling.fit(X_imb, y_imb)

复制代码

8.3 交叉验证的正确使用

交叉验证应该在整个预处理流程之后进行，而不是之前。

2. # 错误示例：先进行交叉验证，再进行预处理
3. cv_scores_wrong = cross_val_score(LogisticRegression(), X, y, cv=5)
5. # 正确示例：使用Pipeline将预处理和模型结合，然后进行交叉验证
6. pipeline = Pipeline([
7.     ('scaler', StandardScaler()),
8.     ('classifier', LogisticRegression())
9. ])
10. cv_scores_correct = cross_val_score(pipeline, X, y, cv=5)
12. print(f"错误交叉验证得分: {cv_scores_wrong}")
13. print(f"正确交叉验证得分: {cv_scores_correct}")

复制代码

8.4 模型选择与评估

在模型选择和评估过程中，应该使用独立的数据集进行最终评估。

2. # 划分数据为训练集、验证集和测试集
3. X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
4. X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42)
6. print(f"训练集大小: {X_train.shape[0]}")
7. print(f"验证集大小: {X_val.shape[0]}")
8. print(f"测试集大小: {X_test.shape[0]}")
10. # 在训练集上训练模型，在验证集上选择最佳模型
11. pipeline = Pipeline([
12.     ('scaler', StandardScaler()),
13.     ('classifier', LogisticRegression())
14. ])
16. pipeline.fit(X_train, y_train)
17. val_score = pipeline.score(X_val, y_val)
19. # 在测试集上评估最终模型
20. test_score = pipeline.score(X_test, y_test)
22. print(f"验证集得分: {val_score:.4f}")
23. print(f"测试集得分: {test_score:.4f}")

复制代码

9. 结论

本文全面介绍了使用scikit-learn进行模型评估与预测的核心技能，从基础指标到高级技巧。我们学习了各种评估指标的使用方法、交叉验证技术、超参数调优策略以及模型预测和持久化的方法。通过实战案例，我们展示了如何将这些技术应用到真实数据集上，并讨论了常见的陷阱和最佳实践。

掌握这些技能将帮助你更好地评估机器学习模型的性能，选择最适合特定问题的模型，并将模型应用到实际场景中。记住，模型评估与预测是机器学习项目成功的关键环节，需要仔细考虑数据特点、业务需求和评估指标的选择。

随着你经验的积累，你将能够更加熟练地运用这些技术，并探索更高级的方法来解决复杂的机器学习问题。希望本文能为你的机器学习之旅提供有价值的指导。