Scikit-learn模型评估完全指南：分类回归指标、交叉验证与调参实战

我见过不少同学，模型训练跑得飞起，各种算法轮着试，最后被问一句“你这个模型到底怎么样”，就只能甩出一行 accuracy_score。这不行，真的不行。模型评估不是训练完随手打个分，它是整个机器学习流程里最容易被低估、却最能决定项目成败的一环。

用 Scikit-learn 做模型评估，是 Python 机器学习里最成熟、最省事的一条路。这个库把常用的指标、交叉验证、学习曲线、超参搜索全都封装好了，你用好了它，就能在期末项目、比赛、论文实验甚至真实业务里拿出让人信服的评估结论。这篇东西我按自己做项目时的习惯来写，从评估思路到分类、回归指标，再到交叉验证和调参防泄漏，把能踩的坑都给你标出来。适合刚学完 sklearn 基础、准备认真做模型评估的人，也适合要交课程设计或者跑对比实验的同学。

1. 项目概述与评估思路设计

1.1 模型评估到底在解决什么问题

先说一个核心观点：模型评估的目的不是“证明我的模型好”，而是“客观知道我的模型在真实场景里大概什么水平”。

你要是只在自己的训练集上算指标，那个数字没有意义。模型在训练时已经见过这些样本了，你再拿同样的样本去考它，分数当然好看，但换个新数据就露馅。评估要解决的核心问题，就是“没见过的新数据来了，模型能不能扛住”。所以 sklearn 里所有评估思路，都在围绕一件事：怎么模拟“新数据”这个条件。

这就要说到数据划分。最简单的做法是把数据切成训练集和测试集，训练集用来学参数，测试集用来当“新数据”打分。这是评估的地基，地基打不好，后面所有指标都是空中楼阁。我在实际项目里见过不少人，拿全量数据训完模型，再拿同一份数据算准确率，然后报给业务方。这个数字没有任何参考价值，测试集必须有、必须严格隔离。

1.2 评估方案怎么定才不返工

我个人的习惯是，拿到一个建模任务，先不急着跑模型，先把评估方案定下来。一句话说就是：先想清楚“什么算好”，再动手。

这个“什么算好”，要回答三个问题。

第一个问题，这是分类还是回归。分类看准确率、精确率、召回率、F1、AUC；回归看 MAE、MSE、RMSE、R2。这两套指标不能混用。你硬要用准确率去评价回归模型，代码都跑不通。

第二个问题，业务对哪类错误更敏感。这特别关键。比如垃圾邮件识别，把正常邮件误判成垃圾邮件，用户会骂；把垃圾邮件漏放过去，顶多多收几封垃圾。这种情况下精确率比召回率重要。反过来，癌症筛查场景，漏诊一个病人的代价远大于误诊，这时候召回率优先。同一个模型，评估重点不同，选型就完全不同。这个决策必须在建模之前做，不然后面指标不合适，整个评估都要重来。

第三个问题，样本量够不够。样本量小的时候，一次训练测试划分的运气成分太大，需要上交叉验证。样本量够大，单次划分也能说明问题，但交叉验证仍然是更稳的选择。

这三个问题想清楚，评估方案就定了一大半。剩下的就是具体选哪个函数、传什么参数的问题。

1.3 评估代码的组织方式

我建议从一开始就养成一个习惯：把评估过程封装成固定的一段代码，每次训练完模型直接调用。别每次现写，现写容易漏参数、容易记错函数名。

sklearn 的评估工具主要集中在 sklearn.metrics 和 sklearn.model_selection 两个模块里。metrics 管指标计算，model_selection 管数据划分、交叉验证、超参搜索。这两个模块你要经常翻文档，它们几乎覆盖了所有日常评估需求。

我自己的模板大概长这样：先划分数据，再训练模型，然后在测试集上同时计算四五个指标，打印成一张表。这样每个模型跑出来，横向对比一目了然。后面每一节我都会给你展开讲具体怎么写。

2. 分类模型评估指标详解与实现

2.1 混淆矩阵与四大基础指标

分类评估绕不开混淆矩阵，它是所有分类指标的地基。矩阵里有四个数字：真正例 TP、假正例 FP、真负例 TN、假负例 FN。这四个数字一出来，准确率、精确率、召回率、F1 全都能算。

四个指标里，准确率最容易算，就是“预测对的占总数的比例”。但它也是最坑的。假设一个数据集里 95% 是负类、5% 是正类，你写个无脑程序把所有样本都预测成负类，准确率直接 95%。这个模型什么也没学到，但准确率看着很高。所以类别不平衡的时候，准确率绝对不能用，至少不能单独用。

精确率是“预测为正类的样本里，有多少是真正类”，它衡量的是模型“猜的正类准不准”。召回率是“所有真正的正类里，有多少被找出来了”，它衡量的是模型“找得全不全”。这两个指标永远是此消彼长的关系，你提高阈值让模型更谨慎，精确率上去了，召回率必然下来。F1 就是它俩的调和平均，用来在两者之间取一个平衡。

在 sklearn 里用这几行就能全算出来：

python复制from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

y_true = [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]
y_pred = [1, 0, 1, 0, 0, 1, 0, 1, 1, 0]

print("准确率:", accuracy_score(y_true, y_pred))
print("精确率:", precision_score(y_true, y_pred))
print("召回率:", recall_score(y_true, y_pred))
print("F1:", f1_score(y_true, y_pred))
print("混淆矩阵:\n", confusion_matrix(y_true, y_pred))

confusion_matrix 返回的是一个二维数组，第一行是真实为负类的样本，第二行是真实为正类的样本，列则对应预测结果。新手最容易在这里看反，我建议你打印出来之后手动核对一遍，确认自己对行列的理解和文档一致，不然后面的精确率召回率全是错的理解。

2.2 精确率和召回率怎么平衡

很多入门教程会告诉你“看 F1 就行”，但实际业务里不是这么简单。我做过一次风控项目，当时模型目标是识别欺诈交易。这个场景里，漏掉一笔欺诈涉及的金额可能很大，所以业务方的要求是“宁可多拦几笔正常的，也不能放过欺诈”。这就决定了评估指标应该偏向召回率。

反过来还有一个场景，内容审核系统。上线初期如果误杀太多正常内容，用户体验会暴跌，所以更看重精确率。这就是为什么我一直强调，评估指标的选择本质上是业务决策，不是技术决策。

那怎么调精确率和召回率的平衡呢？一个非常直接的方法是调整决策阈值。sklearn 的 predict_proba 会输出每个样本属于正类的概率，默认情况下概率大于 0.5 判为正类。你可以把这个阈值提高，比如 0.7 以上才判为正类，精确率通常就会上升，召回率下降；阈值降低，召回率上升，精确率下降。

有没有一个自动找最优阈值的办法？有，但这属于模型调优的范畴，不是简单调用一个函数就能搞定的，通常要结合业务成本来算。最简单的做法是画出 PR 曲线，看不同阈值下精确率和召回率的变化，再根据业务需求挑一个折中点。sklearn 的 metrics.plot_precision_recall_curve 可以直接帮你画这个曲线。

2.3 ROC与AUC的适用场景

ROC 曲线和 AUC 是另一套评估工具，它们在二分类里用得非常多。ROC 曲线的横轴是假正例率，纵轴是真正例率，曲线上每个点对应一个不同的分类阈值。AUC 是曲线下方的面积，数值上等于“随机抽一个正样本和一个负样本，模型把正样本排在前面的概率”。

这个解释很多人记不住，我说个直觉版本：AUC 衡量的是模型把正类排在负类前面的能力。它不关心具体的分数绝对值，只关心排序。所以 AUC 对类别不平衡相对不敏感，正负样本比例怎么变，AUC 的参考价值都还在。这就是为什么在不少不平衡数据集上，大家更愿意看 AUC 而不是准确率。

sklearn 里计算 AUC 的代码很简单：

python复制from sklearn.metrics import roc_auc_score

# y_prob 是模型输出的正类概率
y_prob = [0.9, 0.3, 0.8, 0.4, 0.35, 0.7, 0.2, 0.55, 0.65, 0.45]
auc = roc_auc_score(y_true, y_prob)
print("AUC:", auc)

注意 roc_auc_score 接收的第二个参数是概率分数，不是预测类别。如果你直接传预测类别进去，AUC 会变成一堆 0 和 1 的排序，结果会失真。这是我见过的高频错误，写代码的时候一定要留意。

AUC 有一个短板：当正负样本极度不平衡，比如正类只有 1%，AUC 可能仍然很高，但模型实际效果却不理想。因为负样本数量巨大，模型只要把极少数的正样本排前面，AUC 就漂亮。这种情况下，PR 曲线或者 F1 会更真实。这也是为什么“别只看一个指标”这句话在任何时候都成立。

2.4 分类评估完整代码

下面给你一个更完整的示例，直接跑就能用。我先用 make_classification 造一个二分类数据集，然后用逻辑回归训练，在测试集上把所有常用指标一次性算出来。

python复制from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, precision_score, recall_score,
                             f1_score, roc_auc_score, confusion_matrix)

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15,
                           n_redundant=5, weights=[0.7, 0.3], random_state=42)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

print("准确率: {:.4f}".format(accuracy_score(y_test, y_pred)))
print("精确率: {:.4f}".format(precision_score(y_test, y_pred)))
print("召回率: {:.4f}".format(recall_score(y_test, y_pred)))
print("F1:     {:.4f}".format(f1_score(y_test, y_pred)))
print("AUC:    {:.4f}".format(roc_auc_score(y_test, y_prob)))
print("混淆矩阵:")
print(confusion_matrix(y_test, y_pred))

这里我特别加了 stratify=y，就是为了保证训练集和测试集里的正负比例和原始数据一致，分类任务里这个参数我几乎必加。它在样本量不大时尤其重要，不加的话，小概率出现某一类在测试集里特别少的情况，指标会剧烈波动。

3. 回归模型评估指标详解与实现

3.1 常用回归指标怎么选

回归任务的评估指标和分类完全不一样。分类看的是“分对了没有”，回归看的是“预测值和真实值差多少”。sklearn 的回归指标主要在 sklearn.metrics 里，常用的有四个：MAE、MSE、RMSE、R2。

MAE 是平均绝对误差，就是每个样本预测误差取绝对值再求平均。它的优点是直观，误差的单位和预测目标一样，比如你在预测房价，MAE 就是“平均每套房差多少钱”。缺点是对异常值不敏感，个别离谱的预测错误会被平均掉。

MSE 是平均平方误差，误差先平方再平均。因为平方放大了大误差，所以它对异常值非常敏感，一个极端预测就能把 MSE 拉得很高。RMSE 就是 MSE 开根号，把量纲还原回来，实际用起来比 MSE 好解释一些。

这里有个经典问题：MAE 和 RMSE 哪个好用？我个人的经验是，如果你不想让少数离群样本主导评估结果，用 MAE；如果你希望模型对巨大误差付出代价，用 RMSE。业务场景往往倾向于 RMSE，因为真实世界里，一个预测偏差极大的样本带来的损失可能远超多个小偏差的总和。

R2 是决定系数，它衡量模型解释了目标变量多少比例的方差。R2 最大是 1，代表模型完美拟合；0 代表模型和“直接用均值预测”效果一样；负数说明模型比均值预测还差。这个指标的优点是相对值，可以在不同数据集或不同模型间参考，但绝对值大小和数据本身的难度强相关，别跨业务硬比。

3.2 回归评估完整代码

我造一个简单的回归数据集，分别训练线性回归和随机森林回归，把四个指标都算出来做个对比。这样你能直观看到不同模型在相同数据上的评估结果差异。

python复制from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

X, y = make_regression(n_samples=800, n_features=10, noise=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

models = {
    "LinearRegression": LinearRegression(),
    "RandomForest": RandomForestRegressor(n_estimators=100, random_state=42)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    mae = mean_absolute_error(y_test, y_pred)
    mse = mean_squared_error(y_test, y_pred)
    rmse = np.sqrt(mse)
    r2 = r2_score(y_test, y_pred)
    print("{}: MAE={:.4f}, MSE={:.4f}, RMSE={:.4f}, R2={:.4f}".format(name, mae, mse, rmse, r2))

跑出来的结果你大概率会看到，随机森林在非线性数据上 R2 更高、RMSE 更小。但这里我要提醒一句：评估指标只能告诉你哪个模型在这场测试里表现更好，不能告诉你它在新环境里一定更稳。真实项目里还要考虑模型的可解释性、推理速度、上线成本，这些是指标之外的决策因素。

4. 交叉验证：让评估结果更稳定

4.1 K折交叉验证的原理

单次划分训练集和测试集的问题是，结果取决于你这次划分的运气。某次划分里测试集恰好比较简单，指标就虚高；恰好比较复杂，指标就偏低。K 折交叉验证就是来缓解这个问题的。

思路不复杂：把训练数据平均分成 K 份，每一轮拿其中 K-1 份训练、剩下 1 份做验证，轮流 K 次，最后把 K 次评分取平均。这样每个样本都有机会当验证数据，评估结果对数据划分方式不敏感，比单次划分可靠得多。

最常见的 K 值取 5 或 10。取 10 的时候，每次训练用 90% 的数据，模型见到的样本更接近全量，偏差小，但训练次数多、耗时高。取 5 的时候，速度快，但每次只用了 80% 数据，偏差略大。我个人的经验是，样本量在几千级别用 10 折，几万以上用 5 折，样本量只有几百的时候就别用交叉验证了，直接用留一法或者谨慎地做一次性划分。

4.2 交叉验证的几种变体

sklearn 里除了基础的 KFold，还有几个常用变体，适用范围不一样，别搞混。

StratifiedKFold 是分层 K 折。它在切分时保持每一折里类别比例和原始数据一致。分类任务里我基本只用它，不用普通 KFold。道理和前面 train_test_split 加 stratify 一样，防止某一折里正类特别少导致指标失真。

LeaveOneOut 是留一法，每次只留一个样本做验证。这个对数据量的利用最充分，但要训练 N 次，样本量大根本跑不动。它只在几百个样本的小数据集上才有实用价值。

RepeatedKFold 是重复 K 折，把整个 K 折过程重复多次，每次使用不同的随机切分。它对评估结果更求稳，通常用在需要非常精确评估的场景，比如论文实验。代价是训练时间成倍增加，自己掂量。

4.3 cross_val_score实操

实际写代码时，我推荐直接用 cross_val_score，它会自动完成“划分→训练→评估”的全流程。比如 5 折交叉验证评估逻辑回归的准确率和 AUC，可以这样写：

python复制from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=500, n_features=15, n_informative=8,
                           n_redundant=3, random_state=42)

model = LogisticRegression(max_iter=1000)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

scores = cross_val_score(model, X, y, cv=cv, scoring="f1")
print("每折F1:", scores)
print("平均F1: {:.4f}, 标准差: {:.4f}".format(scores.mean(), scores.std()))

注意 cross_val_score 返回的是一个数组，我在工程里会同时打印平均值和标准差。光看平均值不够，标准差大说明模型在不同折上的表现波动大，这可能意味着数据不太稳定或者模型对数据划分敏感。这个信息在单次划分里是看不到的，属于交叉验证的额外福利。

另外 scoring 参数可以传很多值：accuracy、precision、recall、f1、roc_auc、r2、neg_mean_squared_error 等等。我建议你把 scoring 的选择和业务目标绑定，别停留在默认值。

5. 模型评估的进阶实操：对比、调参与防泄漏

5.1 训练集、验证集、测试集的分工

很多入门的同学以为只有训练集和测试集，这是后面会出大问题的根源。当你开始调参时，只分两组是不够的。

标准做法是分三组：训练集、验证集、测试集。训练集用来学模型参数，验证集用来在调参过程中反复评估和选择模型，测试集从头到尾不碰。等你用验证集把模型和超参都确定下来之后，最后才拿测试集做一次终极评估，这个分数才是你对模型真实泛化能力的判断，可以报给业务方或者写进报告。

为什么要这么严格？因为你在验证集上反复调参，模型的选择已经“看”过验证集了，或多或少会过拟合到验证集上。这时候验证集的分数本身就是偏乐观的，不能代表真实水平。很多人用 GridSearchCV 调完参，直接拿训练时的最佳分数当模型效果，这是不对的。正确做法是调完参后，用一个从未参与任何训练和选择的测试集来确认最终结果。

5.2 数据泄漏：评估里最隐蔽的坑

数据泄漏这个词听起来很专业，其实干的事情就是把“未来信息”提前泄露给了模型，让评估分数虚高。

最典型的例子是特征缩放。假设你跑一个模型，先对全量数据做标准化，再切训练测试集，看起来没问题，实际已经泄漏了。标准化时用到了全量数据的均值和方差，其中包含测试集的统计信息。也就是说，测试集的信息在训练时就已经被模型间接看到了。正确做法是先切分，再只对训练集 fit 标准化器，然后用同一个标准化器去 transform 测试集。

sklearn 里解决这个问题的最优雅方式是 Pipeline。把预处理和模型一次性封装进流水线，交给交叉验证去跑，它在内部每一份数据上都只利用训练部分的信息，不会泄漏。我强烈建议你从一开始就用 Pipeline 组织代码，能省掉一大类麻烦。

5.3 GridSearchCV调参时的评估联动

GridSearchCV 是 sklearn 里最常用的超参搜索工具，它本质上就是“每组超参跑一遍交叉验证，取平均分最高的那组”。它是把交叉验证和调参结合起来的核心接口。

需要注意的有两点。第一点是 scoring 参数要按业务目标设置，GridSearchCV 默认用的是模型自带的 score 方法，很多场景下并不合适。比如二分类不平衡数据，默认的 accuracy 就不合适，你最好显式指定为 f1 或 roc_auc。第二点是调参过程本身会造成前面说的“验证集过拟合”，所以调参结束后，一定要用独立测试集做最终确认。

下面是一个用 Pipeline 加 GridSearchCV 的完整示例，包含标准化和逻辑回归调参：

python复制from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, train_test_split, StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score

X, y = make_classification(n_samples=800, n_features=10, weights=[0.8, 0.2],
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
                                                    random_state=42, stratify=y)

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", LogisticRegression(max_iter=1000))
])

param_grid = {
    "clf__C": [0.01, 0.1, 1, 10],
    "clf__solver": ["liblinear"]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(pipeline, param_grid, cv=cv, scoring="f1", n_jobs=-1)
grid.fit(X_train, y_train)

print("最佳参数:", grid.best_params_)
print("调参过程最佳F1: {:.4f}".format(grid.best_score_))

y_pred = grid.predict(X_test)
print("测试集准确率: {:.4f}".format(accuracy_score(y_test, y_pred)))

注意 param_grid 里的键写得像 clf__C，两个下划线的意思是“Pipeline 里名为 clf 的步骤的参数 C”。这个命名规则是 sklearn 的约定，写错一个下划线就搜不到参数，新手很容易卡在这里。

5.4 模型对比的评估规范

不同模型做对比时，有两个规范必须遵守：一是所有模型必须在完全相同的训练集和测试集上评估，二是评估指标和评估方式要完全一致。不然对比出来的差异不能归因于模型本身，而可能来自数据划分不同、预处理不同这些无关因素。

我自己的做法是先把数据划分固定下来，训练集、测试集的 random_state 固定，然后对所有模型走同一个 Pipeline 和同一个 cross_val_score 设置。有时候还要跑多次取均值，来消除随机性带来的误差。尤其是深度学习或者带随机性的模型，单次评估结果根本不可信，至少跑 5 次取平均值再对比。

6. 常见问题与排查技巧实录

6.1 类别不平衡时指标失真

这是我在实际项目里遇到最多的问题。举个具体的例子，二分类里正类只占 2%，你用默认的 accuracy 去看，随便一个全预测负类的模型都能拿到 98% 的准确率。看着漂亮，实际一无是处。

这种情况下我建议重点关注这几个方向：用 StratifiedKFold 做交叉验证；评估指标换成 f1、precision_recall、roc_auc；查看 classification_report 输出的每一类指标，不要只看整体。如果你需要给业务方看，我会推荐同时报告“整体准确率”和“正类召回率”两个数字，后者才是模型在关键类别上的真实能力。

6.2 随机种子不固定导致结果不可复现

这个坑特别隐蔽。你的模型里但凡有一丁点随机性，比如 train_test_split 不设 random_state、模型里不设 random_state、交叉验证不设置 shuffle 和 random_state，那么每次运行代码，评估结果都会不一样。最离谱的时候，同一个模型在同一个数据集上跑两次，F1 能差出好几个百分点。

解决办法也很简单：你在项目里给所有涉及随机过程的函数都设上 random_state，并且在代码最前面用 np.random.seed(42) 这类方式统一固定全局随机状态。这样别人拿你的代码复现实验，才能得到和你一样的结果。论文、比赛、课程项目里，这个细节往往是扣分点。

6.3 多分类任务里的average参数

如果你的任务是三分类以上，直接拿二分类的评估代码去跑，大概率会报错或者算出一堆让你看不懂的数字。因为精确率、召回率、F1 在多分类里需要对每个类别分别计算，然后再聚合。sklearn 通过 average 参数来控制聚合方式。

macro 是每个类别各自算指标然后取算术平均，它不考虑类别样本量，适合类别相对均衡时使用。micro 是先把所有类别的 TP、FP、FN 加起来，再统一计算指标，它受大类别影响更大，适合类别不平衡时使用。weighted 是 macro 的加权版，按照每个类别的样本量占比加权平均，是很多项目里的实用默认选项。实际用哪个，取决于你是否关心小类别的表现。

6.4 关于模型评估的几点个人经验

做模型评估这几年，我最大的感受是：评估不是一个“跑一下”的动作，而是一套需要提前设计的流程。你定义了什么是指标、怎么划分数据、怎么交叉验证、怎么排除泄漏，这些决定了下游所有结论的可靠性。

我再分享一个建议：每次跑完评估，把结果记下来。我习惯用一张表记录模型名称、特征组合、关键参数、测试集指标，至少记下 F1、AUC、RMSE 这几个核心值。不要信自己的记忆力，一次调参实验可能跑十几个组合，隔周再看全忘。有了记录，你后面写报告、复盘、跟业务方解释结论都会轻松很多。模型评估做扎实了，你才真正知道自己的模型值不值得上线，这也是从“会调库”到“会做项目”的关键一步。