活动公告

系统通知
通知：端午节限时活动来袭！
06-18 23:43
系统通知
通知：微软邮箱更换提醒
06-14 00:00
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

实用scikit-learn模型评估与调优方法提升数据科学项目成功率与模型精度

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

3077

科技点

3万

积分

执行版主

碾压王

积分
32876

塔罗立华奏
执行版主 发表于 2025-9-28 14:40:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

在数据科学项目中，模型评估与调优是确保模型性能和项目成功的关键环节。scikit-learn作为Python中最流行的机器学习库之一，提供了丰富的工具和方法用于模型评估和参数调优。本文将深入探讨如何利用scikit-learn中的各种技术来系统性地评估模型性能，优化模型参数，从而提升数据科学项目的成功率和模型精度。

良好的模型评估可以帮助我们了解模型的真实性能，避免过拟合和欠拟合问题；而有效的模型调优则能够找到最优的参数组合，最大化模型的预测能力。通过掌握这些技术，数据科学家可以更加自信地部署模型，并在实际应用中取得更好的效果。

模型评估基础

评估指标介绍

在机器学习中，选择合适的评估指标对于准确衡量模型性能至关重要。scikit-learn提供了多种评估指标，适用于不同类型的问题。

对于分类问题，常用的评估指标包括准确率(Accuracy)、精确率(Precision)、召回率(Recall)、F1分数等。
  2. from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
  3. from sklearn.datasets import make_classification
  4. from sklearn.model_selection import train_test_split
  5. from sklearn.ensemble import RandomForestClassifier
  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.3, random_state=42)
  11. # 训练模型
  12. clf = RandomForestClassifier(random_state=42)
  13. clf.fit(X_train, y_train)
  15. # 预测
  16. y_pred = clf.predict(X_test)
  18. # 计算各项指标
  19. accuracy = accuracy_score(y_test, y_pred)
  20. precision = precision_score(y_test, y_pred)
  21. recall = recall_score(y_test, y_pred)
  22. f1 = f1_score(y_test, y_pred)
  24. print(f"准确率: {accuracy:.4f}")
  25. print(f"精确率: {precision:.4f}")
  26. print(f"召回率: {recall:.4f}")
  27. print(f"F1分数: {f1:.4f}")
  29. # 使用classification_report获取完整的评估报告
  30. print("\n分类报告:")
  31. print(classification_report(y_test, y_pred))
复制代码

对于回归问题，常用的评估指标包括均方误差(MSE)、均方根误差(RMSE)、平均绝对误差(MAE)和决定系数(R²)等。
  2. from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
  3. from sklearn.datasets import make_regression
  4. from sklearn.ensemble import RandomForestRegressor
  5. import numpy as np
  7. # 生成模拟数据
  8. X, y = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
  9. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  11. # 训练模型
  12. reg = RandomForestRegressor(random_state=42)
  13. reg.fit(X_train, y_train)
  15. # 预测
  16. y_pred = reg.predict(X_test)
  18. # 计算各项指标
  19. mse = mean_squared_error(y_test, y_pred)
  20. rmse = np.sqrt(mse)
  21. mae = mean_absolute_error(y_test, y_pred)
  22. r2 = r2_score(y_test, y_pred)
  24. print(f"均方误差(MSE): {mse:.4f}")
  25. print(f"均方根误差(RMSE): {rmse:.4f}")
  26. print(f"平均绝对误差(MAE): {mae:.4f}")
  27. print(f"决定系数(R²): {r2:.4f}")
复制代码

交叉验证方法

交叉验证是一种稳健的模型评估方法，可以减少因数据划分不同而导致的评估结果波动。scikit-learn提供了多种交叉验证策略。

K折交叉验证将数据集分成K个子集，每次使用K-1个子集进行训练，剩下的1个子集用于验证，重复K次，最后取平均性能作为评估结果。
  2. from sklearn.model_selection import cross_val_score, KFold
  3. from sklearn.svm import SVC
  5. # 使用之前生成的分类数据
  6. clf = SVC(random_state=42)
  8. # 5折交叉验证
  9. kfold = KFold(n_splits=5, shuffle=True, random_state=42)
  10. scores = cross_val_score(clf, X, y, cv=kfold, scoring='accuracy')
  12. print(f"各折准确率: {scores}")
  13. print(f"平均准确率: {scores.mean():.4f}")
  14. print(f"准确率标准差: {scores.std():.4f}")
复制代码

对于分类问题，特别是类别不平衡的情况，分层K折交叉验证可以确保每个折中各类别的比例与完整数据集中的比例相同。
  2. from sklearn.model_selection import StratifiedKFold
  4. # 分层5折交叉验证
  5. stratified_kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
  6. scores = cross_val_score(clf, X, y, cv=stratified_kfold, scoring='accuracy')
  8. print(f"各折准确率: {scores}")
  9. print(f"平均准确率: {scores.mean():.4f}")
  10. print(f"准确率标准差: {scores.std():.4f}")
复制代码

留一交叉验证(Leave-One-Out, LOO)是K折交叉验证的特例，其中K等于样本数量。每次只用一个样本进行验证，其余样本用于训练。
  2. from sklearn.model_selection import LeaveOneOut
  4. # 留一交叉验证（注意：计算成本高，适合小数据集）
  5. loo = LeaveOneOut()
  6. scores = cross_val_score(clf, X[:100], y[:100], cv=loo, scoring='accuracy')  # 只使用前100个样本以节省时间
  8. print(f"平均准确率: {scores.mean():.4f}")
  9. print(f"准确率标准差: {scores.std():.4f}")
复制代码

对于时间序列数据，需要使用特殊的交叉验证方法，以确保训练集始终在验证集之前。
  2. from sklearn.model_selection import TimeSeriesSplit
  3. from sklearn.linear_model import LinearRegression
  5. # 创建时间序列数据
  6. t = np.linspace(0, 10, 100)
  7. X_ts = np.sin(t).reshape(-1, 1)
  8. y_ts = np.cos(t)
  10. # 时间序列交叉验证
  11. tscv = TimeSeriesSplit(n_splits=5)
  12. model = LinearRegression()
  13. scores = cross_val_score(model, X_ts, y_ts, cv=tscv, scoring='neg_mean_squared_error')
  15. print(f"各折MSE: {-scores}")
  16. print(f"平均MSE: {-scores.mean():.4f}")
  17. print(f"MSE标准差: {scores.std():.4f}")
复制代码

学习曲线分析

学习曲线可以帮助我们诊断模型是否存在过拟合或欠拟合问题，以及是否需要更多数据来提升模型性能。
  2. import matplotlib.pyplot as plt
  3. from sklearn.model_selection import learning_curve
  5. def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
  6.                         n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):
  7.     """
  8.     生成并绘制学习曲线
  9.     """
  10.     plt.figure(figsize=(10, 6))
  11.     plt.title(title)
  12.     if ylim is not None:
  13.         plt.ylim(*ylim)
  14.     plt.xlabel("训练样本数")
  15.     plt.ylabel("得分")
  16.    
  17.     train_sizes, train_scores, test_scores = learning_curve(
  18.         estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
  19.    
  20.     train_scores_mean = np.mean(train_scores, axis=1)
  21.     train_scores_std = np.std(train_scores, axis=1)
  22.     test_scores_mean = np.mean(test_scores, axis=1)
  23.     test_scores_std = np.std(test_scores, axis=1)
  24.    
  25.     plt.grid()
  26.    
  27.     plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
  28.                      train_scores_mean + train_scores_std, alpha=0.1,
  29.                      color="r")
  30.     plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
  31.                      test_scores_mean + test_scores_std, alpha=0.1, color="g")
  32.     plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
  33.              label="训练集得分")
  34.     plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
  35.              label="交叉验证集得分")
  36.    
  37.     plt.legend(loc="best")
  38.     return plt
  40. # 使用随机森林分类器绘制学习曲线
  41. title = "学习曲线 (随机森林)"
  42. cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
  43. estimator = RandomForestClassifier(random_state=42)
  44. plot_learning_curve(estimator, title, X, y, ylim=(0.7, 1.01), cv=cv, n_jobs=4)
  46. plt.show()
复制代码

通过分析学习曲线，我们可以得出以下结论：

• 如果训练得分和验证得分都较低，且差距不大，则模型可能欠拟合。
• 如果训练得分很高，而验证得分较低，则模型可能过拟合。
• 如果两条曲线都趋于平稳，但仍有较大差距，则增加更多数据可能无法显著提升模型性能。

模型调优技术

网格搜索

网格搜索(GridSearchCV)是一种穷举式的参数调优方法，它会尝试所有可能的参数组合，通过交叉验证评估每种组合的性能，最终选择最佳参数组合。
  2. from sklearn.model_selection import GridSearchCV
  3. from sklearn.pipeline import Pipeline
  4. from sklearn.preprocessing import StandardScaler
  6. # 创建一个包含预处理和分类的管道
  7. pipe = Pipeline([
  8.     ('scaler', StandardScaler()),
  9.     ('clf', RandomForestClassifier(random_state=42))
  10. ])
  12. # 定义参数网格
  13. param_grid = {
  14.     'clf__n_estimators': [50, 100, 200],
  15.     'clf__max_depth': [None, 10, 20, 30],
  16.     'clf__min_samples_split': [2, 5, 10],
  17.     'clf__min_samples_leaf': [1, 2, 4]
  18. }
  20. # 创建网格搜索对象
  21. grid_search = GridSearchCV(
  22.     estimator=pipe,
  23.     param_grid=param_grid,
  24.     scoring='accuracy',
  25.     cv=5,
  26.     n_jobs=-1,  # 使用所有可用的CPU核心
  27.     verbose=1
  28. )
  30. # 执行网格搜索
  31. grid_search.fit(X_train, y_train)
  33. # 输出最佳参数和对应的得分
  34. print(f"最佳参数: {grid_search.best_params_}")
  35. print(f"最佳交叉验证得分: {grid_search.best_score_:.4f}")
  37. # 使用最佳模型进行预测
  38. best_model = grid_search.best_estimator_
  39. y_pred = best_model.predict(X_test)
  40. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")
复制代码

随机搜索

随机搜索(RandomizedSearchCV)与网格搜索类似，但它不是尝试所有可能的参数组合，而是从参数空间中随机采样固定数量的参数组合进行评估。这种方法通常比网格搜索更高效，特别是当参数空间较大时。
  2. from sklearn.model_selection import RandomizedSearchCV
  3. from scipy.stats import randint
  5. # 定义参数分布
  6. param_dist = {
  7.     'clf__n_estimators': randint(50, 500),
  8.     'clf__max_depth': [None] + list(randint(5, 50).rvs(10)),
  9.     'clf__min_samples_split': randint(2, 20),
  10.     'clf__min_samples_leaf': randint(1, 10),
  11.     'clf__max_features': ['auto', 'sqrt', 'log2']
  12. }
  14. # 创建随机搜索对象
  15. random_search = RandomizedSearchCV(
  16.     estimator=pipe,
  17.     param_distributions=param_dist,
  18.     n_iter=50,  # 尝试50种随机参数组合
  19.     scoring='accuracy',
  20.     cv=5,
  21.     n_jobs=-1,
  22.     verbose=1,
  23.     random_state=42
  24. )
  26. # 执行随机搜索
  27. random_search.fit(X_train, y_train)
  29. # 输出最佳参数和对应的得分
  30. print(f"最佳参数: {random_search.best_params_}")
  31. print(f"最佳交叉验证得分: {random_search.best_score_:.4f}")
  33. # 使用最佳模型进行预测
  34. best_model = random_search.best_estimator_
  35. y_pred = best_model.predict(X_test)
  36. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")
复制代码

贝叶斯优化

贝叶斯优化是一种更智能的参数优化方法，它利用之前的评估结果来指导下一轮的参数选择。虽然scikit-learn本身没有直接提供贝叶斯优化的实现，但我们可以使用第三方库如scikit-optimize或BayesianOptimization来实现。
  2. # 首先安装必要的库
  3. # !pip install scikit-optimize
  5. from skopt import BayesSearchCV
  6. from skopt.space import Real, Categorical, Integer
  8. # 定义搜索空间
  9. search_space = {
  10.     'clf__n_estimators': Integer(50, 500),
  11.     'clf__max_depth': Integer(5, 50),
  12.     'clf__min_samples_split': Integer(2, 20),
  13.     'clf__min_samples_leaf': Integer(1, 10),
  14.     'clf__max_features': Categorical(['auto', 'sqrt', 'log2'])
  15. }
  17. # 创建贝叶斯优化对象
  18. bayes_search = BayesSearchCV(
  19.     estimator=pipe,
  20.     search_spaces=search_space,
  21.     n_iter=30,  # 尝试30种参数组合
  22.     scoring='accuracy',
  23.     cv=5,
  24.     n_jobs=-1,
  25.     verbose=1,
  26.     random_state=42
  27. )
  29. # 执行贝叶斯优化
  30. bayes_search.fit(X_train, y_train)
  32. # 输出最佳参数和对应的得分
  33. print(f"最佳参数: {bayes_search.best_params_}")
  34. print(f"最佳交叉验证得分: {bayes_search.best_score_:.4f}")
  36. # 使用最佳模型进行预测
  37. best_model = bayes_search.best_estimator_
  38. y_pred = best_model.predict(X_test)
  39. print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")
复制代码

基于进化算法的优化

进化算法是另一种高效的参数优化方法，它模拟生物进化过程，通过选择、交叉和变异等操作来逐步优化参数组合。我们可以使用库如DEAP或TPOT来实现基于进化算法的参数优化。
  2. # 首先安装必要的库
  3. # !pip install tpot
  5. from tpot import TPOTClassifier
  7. # 创建TPOT分类器
  8. tpot = TPOTClassifier(
  9.     generations=5,  # 进化代数
  10.     population_size=20,  # 每代种群大小
  11.     cv=5,
  12.     scoring='accuracy',
  13.     n_jobs=-1,
  14.     verbosity=2,
  15.     random_state=42
  16. )
  18. # 运行TPOT优化
  19. tpot.fit(X_train, y_train)
  21. # 输出最佳得分
  22. print(f"最佳交叉验证得分: {tpot.score(X_test, y_test):.4f}")
  24. # 导出最佳模型
  25. tpot.export('tpot_best_pipeline.py')
复制代码

特征选择与工程

特征重要性评估

许多模型，如随机森林和梯度提升树，能够提供特征重要性的评估，帮助我们理解哪些特征对模型的预测贡献最大。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  5. # 使用随机森林评估特征重要性
  6. rf = RandomForestClassifier(n_estimators=100, random_state=42)
  7. rf.fit(X_train, y_train)
  9. # 获取特征重要性
  10. importances = rf.feature_importances_
  11. indices = np.argsort(importances)[::-1]
  13. # 打印特征排名
  14. print("特征排名:")
  15. for f in range(X_train.shape[1]):
  16.     print(f"{f + 1}. 特征 {indices[f]} ({importances[indices[f]]:.4f})")
  18. # 绘制特征重要性图
  19. plt.figure(figsize=(12, 8))
  20. plt.title("特征重要性")
  21. plt.bar(range(X_train.shape[1]), importances[indices], align="center")
  22. plt.xticks(range(X_train.shape[1]), indices)
  23. plt.xlim([-1, X_train.shape[1]])
  24. plt.tight_layout()
  25. plt.show()
复制代码

特征选择方法

scikit-learn提供了多种特征选择方法，包括基于统计测试的方法、基于模型的方法和递归特征消除等。
  2. from sklearn.feature_selection import SelectKBest, f_classif, chi2
  4. # 选择K个最佳特征
  5. selector = SelectKBest(score_func=f_classif, k=10)
  6. X_new = selector.fit_transform(X_train, y_train)
  8. # 获取选择的特征索引
  9. selected_features = selector.get_support(indices=True)
  10. print(f"选择的特征索引: {selected_features}")
  12. # 使用选择的特征训练模型
  13. X_train_selected = selector.transform(X_train)
  14. X_test_selected = selector.transform(X_test)
  16. clf_selected = RandomForestClassifier(random_state=42)
  17. clf_selected.fit(X_train_selected, y_train)
  19. y_pred_selected = clf_selected.predict(X_test_selected)
  20. print(f"使用选择特征的模型准确率: {accuracy_score(y_test, y_pred_selected):.4f}")
复制代码
  2. from sklearn.feature_selection import SelectFromModel
  4. # 使用随机森林进行特征选择
  5. selector = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median')
  6. selector.fit(X_train, y_train)
  8. # 获取选择的特征索引
  9. selected_features = selector.get_support(indices=True)
  10. print(f"选择的特征索引: {selected_features}")
  12. # 使用选择的特征训练模型
  13. X_train_selected = selector.transform(X_train)
  14. X_test_selected = selector.transform(X_test)
  16. clf_selected = RandomForestClassifier(random_state=42)
  17. clf_selected.fit(X_train_selected, y_train)
  19. y_pred_selected = clf_selected.predict(X_test_selected)
  20. print(f"使用选择特征的模型准确率: {accuracy_score(y_test, y_pred_selected):.4f}")
复制代码
  2. from sklearn.feature_selection import RFE
  4. # 创建递归特征消除对象
  5. selector = RFE(estimator=RandomForestClassifier(n_estimators=100, random_state=42), n_features_to_select=10)
  6. selector = selector.fit(X_train, y_train)
  8. # 获取选择的特征索引
  9. selected_features = selector.get_support(indices=True)
  10. print(f"选择的特征索引: {selected_features}")
  12. # 使用选择的特征训练模型
  13. X_train_selected = selector.transform(X_train)
  14. X_test_selected = selector.transform(X_test)
  16. clf_selected = RandomForestClassifier(random_state=42)
  17. clf_selected.fit(X_train_selected, y_train)
  19. y_pred_selected = clf_selected.predict(X_test_selected)
  20. print(f"使用选择特征的模型准确率: {accuracy_score(y_test, y_pred_selected):.4f}")
复制代码

特征转换与缩放

特征转换和缩放是预处理的重要步骤，可以提高许多机器学习算法的性能。
  2. from sklearn.preprocessing import StandardScaler
  4. # 标准化特征（均值为0，方差为1）
  5. scaler = StandardScaler()
  6. X_train_scaled = scaler.fit_transform(X_train)
  7. X_test_scaled = scaler.transform(X_test)
  9. # 使用标准化后的特征训练模型
  10. clf_scaled = RandomForestClassifier(random_state=42)
  11. clf_scaled.fit(X_train_scaled, y_train)
  13. y_pred_scaled = clf_scaled.predict(X_test_scaled)
  14. print(f"使用标准化特征的模型准确率: {accuracy_score(y_test, y_pred_scaled):.4f}")
复制代码
  2. from sklearn.preprocessing import MinMaxScaler
  4. # 归一化特征（将特征缩放到[0, 1]区间）
  5. scaler = MinMaxScaler()
  6. X_train_scaled = scaler.fit_transform(X_train)
  7. X_test_scaled = scaler.transform(X_test)
  9. # 使用归一化后的特征训练模型
  10. clf_scaled = RandomForestClassifier(random_state=42)
  11. clf_scaled.fit(X_train_scaled, y_train)
  13. y_pred_scaled = clf_scaled.predict(X_test_scaled)
  14. print(f"使用归一化特征的模型准确率: {accuracy_score(y_test, y_pred_scaled):.4f}")
复制代码
  2. from sklearn.decomposition import PCA
  4. # 使用PCA降维
  5. pca = PCA(n_components=10)  # 保留10个主成分
  6. X_train_pca = pca.fit_transform(X_train)
  7. X_test_pca = pca.transform(X_test)
  9. # 使用PCA后的特征训练模型
  10. clf_pca = RandomForestClassifier(random_state=42)
  11. clf_pca.fit(X_train_pca, y_train)
  13. y_pred_pca = clf_pca.predict(X_test_pca)
  14. print(f"使用PCA特征的模型准确率: {accuracy_score(y_test, y_pred_pca):.4f}")
  16. # 查看解释方差比
  17. print(f"解释方差比: {pca.explained_variance_ratio_}")
  18. print(f"累计解释方差比: {np.cumsum(pca.explained_variance_ratio_)}")
复制代码

高级评估技术

混淆矩阵分析

混淆矩阵是评估分类模型性能的强大工具，它可以详细展示模型在各个类别上的预测情况。
  2. from sklearn.metrics import confusion_matrix
  3. import seaborn as sns
  5. # 生成多类别数据
  6. X_multi, y_multi = make_classification(n_samples=1000, n_classes=3, n_informative=5, random_state=42)
  7. X_train, X_test, y_train, y_test = train_test_split(X_multi, y_multi, test_size=0.3, random_state=42)
  9. # 训练模型
  10. clf_multi = RandomForestClassifier(random_state=42)
  11. clf_multi.fit(X_train, y_train)
  13. # 预测
  14. y_pred = clf_multi.predict(X_test)
  16. # 计算混淆矩阵
  17. cm = confusion_matrix(y_test, y_pred)
  19. # 绘制混淆矩阵
  20. plt.figure(figsize=(10, 8))
  21. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
  22. plt.title('混淆矩阵')
  23. plt.ylabel('真实标签')
  24. plt.xlabel('预测标签')
  25. plt.show()
  27. # 打印分类报告
  28. print("\n分类报告:")
  29. print(classification_report(y_test, y_pred))
复制代码

ROC曲线与AUC

ROC曲线和AUC是评估二分类模型性能的重要工具，特别是在类别不平衡的情况下。
  2. from sklearn.metrics import roc_curve, auc, roc_auc_score
  3. from sklearn.datasets import make_classification
  4. from sklearn.model_selection import train_test_split
  5. from sklearn.ensemble import RandomForestClassifier
  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.3, random_state=42)
  11. # 训练模型
  12. clf = RandomForestClassifier(random_state=42)
  13. clf.fit(X_train, y_train)
  15. # 预测概率
  16. y_scores = clf.predict_proba(X_test)[:, 1]
  18. # 计算ROC曲线
  19. fpr, tpr, thresholds = roc_curve(y_test, y_scores)
  20. roc_auc = auc(fpr, tpr)
  22. # 绘制ROC曲线
  23. plt.figure(figsize=(10, 8))
  24. plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC曲线 (AUC = {roc_auc:.2f})')
  25. plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
  26. plt.xlim([0.0, 1.0])
  27. plt.ylim([0.0, 1.05])
  28. plt.xlabel('假正例率')
  29. plt.ylabel('真正例率')
  30. plt.title('接收者操作特征曲线')
  31. plt.legend(loc="lower right")
  32. plt.show()
  34. # 计算AUC
  35. print(f"AUC: {roc_auc_score(y_test, y_scores):.4f}")
复制代码

精确率-召回率曲线

精确率-召回率曲线是另一种评估二分类模型性能的工具，特别关注正类的预测质量。
  2. from sklearn.metrics import precision_recall_curve, average_precision_score
  4. # 计算精确率-召回率曲线
  5. precision, recall, _ = precision_recall_curve(y_test, y_scores)
  6. average_precision = average_precision_score(y_test, y_scores)
  8. # 绘制精确率-召回率曲线
  9. plt.figure(figsize=(10, 8))
  10. plt.plot(recall, precision, color='blue', lw=2, label=f'精确率-召回率曲线 (AP = {average_precision:.2f})')
  11. plt.xlim([0.0, 1.0])
  12. plt.ylim([0.0, 1.05])
  13. plt.xlabel('召回率')
  14. plt.ylabel('精确率')
  15. plt.title('精确率-召回率曲线')
  16. plt.legend(loc="lower left")
  17. plt.show()
  19. # 计算平均精确率
  20. print(f"平均精确率: {average_precision:.4f}")
复制代码

实战案例：端到端的模型评估与调优

让我们通过一个完整的案例来展示如何应用前面介绍的各种技术来评估和调优模型。我们将使用UCI的成人收入数据集，预测个人收入是否超过50K美元/年。
  2. import pandas as pd
  3. from sklearn.compose import ColumnTransformer
  4. from sklearn.impute import SimpleImputer
  5. from sklearn.pipeline import Pipeline
  6. from sklearn.preprocessing import StandardScaler, OneHotEncoder
  7. from sklearn.ensemble import RandomForestClassifier
  8. from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
  9. from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_auc_score
  11. # 加载数据
  12. url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
  13. column_names = ['age', 'workclass', 'fnlwgt', 'education', 'education-num',
  14.                 'marital-status', 'occupation', 'relationship', 'race', 'sex',
  15.                 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country', 'income']
  17. data = pd.read_csv(url, names=column_names, na_values=' ?', skipinitialspace=True)
  19. # 数据预处理
  20. # 将收入列转换为二分类
  21. data['income'] = data['income'].apply(lambda x: 1 if x == '>50K' else 0)
  23. # 分离特征和目标变量
  24. X = data.drop('income', axis=1)
  25. y = data['income']
  27. # 划分训练集和测试集
  28. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
  30. # 定义数值型和类别型特征
  31. numeric_features = ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
  32. categorical_features = ['workclass', 'education', 'marital-status', 'occupation',
  33.                        'relationship', 'race', 'sex', 'native-country']
  35. # 创建预处理管道
  36. numeric_transformer = Pipeline(steps=[
  37.     ('imputer', SimpleImputer(strategy='median')),
  38.     ('scaler', StandardScaler())
  39. ])
  41. categorical_transformer = Pipeline(steps=[
  42.     ('imputer', SimpleImputer(strategy='most_frequent')),
  43.     ('onehot', OneHotEncoder(handle_unknown='ignore'))
  44. ])
  46. preprocessor = ColumnTransformer(
  47.     transformers=[
  48.         ('num', numeric_transformer, numeric_features),
  49.         ('cat', categorical_transformer, categorical_features)
  50.     ])
  52. # 创建完整的模型管道
  53. model = Pipeline(steps=[
  54.     ('preprocessor', preprocessor),
  55.     ('classifier', RandomForestClassifier(random_state=42))
  56. ])
  58. # 定义参数网格
  59. param_grid = {
  60.     'classifier__n_estimators': [100, 200],
  61.     'classifier__max_depth': [None, 10, 20],
  62.     'classifier__min_samples_split': [2, 5],
  63.     'classifier__min_samples_leaf': [1, 2]
  64. }
  66. # 创建网格搜索对象
  67. cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
  68. grid_search = GridSearchCV(
  69.     estimator=model,
  70.     param_grid=param_grid,
  71.     scoring='accuracy',
  72.     cv=cv,
  73.     n_jobs=-1,
  74.     verbose=1
  75. )
  77. # 执行网格搜索
  78. print("开始网格搜索...")
  79. grid_search.fit(X_train, y_train)
  81. # 输出最佳参数和对应的得分
  82. print(f"\n最佳参数: {grid_search.best_params_}")
  83. print(f"最佳交叉验证得分: {grid_search.best_score_:.4f}")
  85. # 使用最佳模型进行预测
  86. best_model = grid_search.best_estimator_
  87. y_pred = best_model.predict(X_test)
  88. y_pred_proba = best_model.predict_proba(X_test)[:, 1]
  90. # 评估模型性能
  91. print(f"\n测试集准确率: {accuracy_score(y_test, y_pred):.4f}")
  92. print(f"AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")
  94. # 打印分类报告
  95. print("\n分类报告:")
  96. print(classification_report(y_test, y_pred))
  98. # 绘制混淆矩阵
  99. cm = confusion_matrix(y_test, y_pred)
  100. plt.figure(figsize=(8, 6))
  101. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
  102. plt.title('混淆矩阵')
  103. plt.ylabel('真实标签')
  104. plt.xlabel('预测标签')
  105. plt.show()
  107. # 特征重要性分析
  108. # 获取特征名称
  109. feature_names = numeric_features + list(best_model.named_steps['preprocessor'].named_transformers_['cat'].named_steps['onehot'].get_feature_names_out(categorical_features))
  111. # 获取特征重要性
  112. importances = best_model.named_steps['classifier'].feature_importances_
  113. indices = np.argsort(importances)[::-1]
  115. # 打印前15个最重要的特征
  116. print("\n前15个最重要的特征:")
  117. for f in range(15):
  118.     print(f"{f + 1}. {feature_names[indices[f]]} ({importances[indices[f]]:.4f})")
  120. # 绘制特征重要性图
  121. plt.figure(figsize=(12, 8))
  122. plt.title("特征重要性")
  123. plt.bar(range(15), importances[indices[:15]], align="center")
  124. plt.xticks(range(15), [feature_names[i] for i in indices[:15]], rotation=90)
  125. plt.tight_layout()
  126. plt.show()
复制代码

这个实战案例展示了如何：

1. 加载和预处理真实数据集
2. 构建包含预处理步骤的完整管道
3. 使用网格搜索进行参数调优
4. 评估模型性能并生成详细的评估报告
5. 分析特征重要性

通过这种端到端的方法，我们可以系统地评估和优化模型，从而在数据科学项目中取得更好的结果。

最佳实践与常见陷阱

最佳实践

1. 始终使用交叉验证避免仅使用单次训练-测试分割来评估模型性能交叉验证可以提供更稳健的性能估计
2. 避免仅使用单次训练-测试分割来评估模型性能
3. 交叉验证可以提供更稳健的性能估计
4. 为问题选择合适的评估指标对于不平衡的数据集，准确率可能会产生误导考虑使用精确率、召回率、F1分数或AUC等指标
5. 对于不平衡的数据集，准确率可能会产生误导
6. 考虑使用精确率、召回率、F1分数或AUC等指标
7. 预处理步骤应包含在交叉验证中使用Pipeline确保预处理和建模步骤正确地应用在交叉验证的每个折中避免数据泄露，即测试集的信息影响训练过程
8. 使用Pipeline确保预处理和建模步骤正确地应用在交叉验证的每个折中
9. 避免数据泄露，即测试集的信息影响训练过程
10. 从简单模型开始先尝试简单的基线模型，然后再尝试更复杂的模型这有助于建立性能基准并理解问题的难度
11. 先尝试简单的基线模型，然后再尝试更复杂的模型
12. 这有助于建立性能基准并理解问题的难度
13. 系统性地进行参数调优使用网格搜索、随机搜索或贝叶斯优化等方法系统性地搜索最佳参数避免手动调参，这通常是低效且不可重复的
14. 使用网格搜索、随机搜索或贝叶斯优化等方法系统性地搜索最佳参数
15. 避免手动调参，这通常是低效且不可重复的
16. 记录实验过程和结果使用工具如MLflow或Weights & Biases跟踪实验记录数据预处理步骤、模型参数和评估结果
17. 使用工具如MLflow或Weights & Biases跟踪实验
18. 记录数据预处理步骤、模型参数和评估结果

始终使用交叉验证

• 避免仅使用单次训练-测试分割来评估模型性能
• 交叉验证可以提供更稳健的性能估计

为问题选择合适的评估指标

• 对于不平衡的数据集，准确率可能会产生误导
• 考虑使用精确率、召回率、F1分数或AUC等指标

预处理步骤应包含在交叉验证中

• 使用Pipeline确保预处理和建模步骤正确地应用在交叉验证的每个折中
• 避免数据泄露，即测试集的信息影响训练过程

从简单模型开始

• 先尝试简单的基线模型，然后再尝试更复杂的模型
• 这有助于建立性能基准并理解问题的难度

系统性地进行参数调优

• 使用网格搜索、随机搜索或贝叶斯优化等方法系统性地搜索最佳参数
• 避免手动调参，这通常是低效且不可重复的

记录实验过程和结果

• 使用工具如MLflow或Weights & Biases跟踪实验
• 记录数据预处理步骤、模型参数和评估结果

常见陷阱

1. 数据泄露在训练之前对整个数据集进行预处理（如标准化、特征选择）解决方案：确保预处理步骤在交叉验证的每个折中独立进行
2. 在训练之前对整个数据集进行预处理（如标准化、特征选择）
3. 解决方案：确保预处理步骤在交叉验证的每个折中独立进行
4. 过拟合验证集反复使用相同的验证集进行模型选择和参数调优解决方案：保留一个独立的测试集，仅在最终评估时使用
5. 反复使用相同的验证集进行模型选择和参数调优
6. 解决方案：保留一个独立的测试集，仅在最终评估时使用
7. 忽略类别不平衡在类别不平衡的数据集上使用准确率作为主要评估指标解决方案：使用精确率、召回率、F1分数或AUC等指标，考虑使用类别权重或过采样/欠采样技术
8. 在类别不平衡的数据集上使用准确率作为主要评估指标
9. 解决方案：使用精确率、召回率、F1分数或AUC等指标，考虑使用类别权重或过采样/欠采样技术
10. 过度调参在参数空间中花费过多时间寻找微小的性能提升解决方案：设定合理的计算预算，关注有意义的性能改进
11. 在参数空间中花费过多时间寻找微小的性能提升
12. 解决方案：设定合理的计算预算，关注有意义的性能改进
13. 忽略模型可解释性只关注模型性能而忽略模型的可解释性解决方案：使用特征重要性、部分依赖图等技术理解模型行为
14. 只关注模型性能而忽略模型的可解释性
15. 解决方案：使用特征重要性、部分依赖图等技术理解模型行为
16. 不检查假设条件不考虑模型对数据的假设条件（如线性模型假设特征间线性关系）解决方案：了解所选模型的假设，并在必要时进行数据转换
17. 不考虑模型对数据的假设条件（如线性模型假设特征间线性关系）
18. 解决方案：了解所选模型的假设，并在必要时进行数据转换

数据泄露

• 在训练之前对整个数据集进行预处理（如标准化、特征选择）
• 解决方案：确保预处理步骤在交叉验证的每个折中独立进行

过拟合验证集

• 反复使用相同的验证集进行模型选择和参数调优
• 解决方案：保留一个独立的测试集，仅在最终评估时使用

忽略类别不平衡

• 在类别不平衡的数据集上使用准确率作为主要评估指标
• 解决方案：使用精确率、召回率、F1分数或AUC等指标，考虑使用类别权重或过采样/欠采样技术

过度调参

• 在参数空间中花费过多时间寻找微小的性能提升
• 解决方案：设定合理的计算预算，关注有意义的性能改进

忽略模型可解释性

• 只关注模型性能而忽略模型的可解释性
• 解决方案：使用特征重要性、部分依赖图等技术理解模型行为

不检查假设条件

• 不考虑模型对数据的假设条件（如线性模型假设特征间线性关系）
• 解决方案：了解所选模型的假设，并在必要时进行数据转换

结论

模型评估与调优是数据科学项目中至关重要的环节。通过本文介绍的scikit-learn工具和技术，我们可以系统性地评估模型性能，优化模型参数，从而提升数据科学项目的成功率和模型精度。

关键要点包括：

1. 使用多种评估指标全面了解模型性能
2. 应用交叉验证获得稳健的性能估计
3. 利用学习曲线诊断过拟合和欠拟合问题
4. 使用网格搜索、随机搜索或贝叶斯优化等方法进行参数调优
5. 通过特征选择和工程提升模型性能
6. 应用高级评估技术如混淆矩阵、ROC曲线和精确率-召回率曲线深入分析模型性能

通过遵循最佳实践并避免常见陷阱，数据科学家可以更加自信地构建和部署高性能的机器学习模型，为实际业务问题提供有效的解决方案。

最终，模型评估与调优不仅是一项技术任务，更是一门艺术。它需要数据科学家结合领域知识、统计理解和实践经验，才能在每个项目中找到最适合的评估策略和调优方法。希望本文提供的指南能够帮助读者在数据科学项目中取得更好的成果。
科学家
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则