D2L模型评估：准确率、召回率、F1分数详解-优快云博客

D2L模型评估：准确率、召回率、F1分数详解

【免费下载链接】d2l-zh 《动手学深度学习》：面向中文读者、能运行、可讨论。中英文版被70多个国家的500多所大学用于教学。项目地址: https://gitcode.com/GitHub_Trending/d2/d2l-zh

引言：模型评估的核心挑战

你是否曾遇到过这样的困境：训练集准确率高达99%的模型，在实际应用中却错漏百出？在深度学习领域，仅依靠单一指标判断模型性能如同盲人摸象。本文将系统解析分类任务中三大核心评估指标——准确率（Accuracy）、召回率（Recall）、F1分数（F1-Score），通过数学原理、代码实现和可视化分析，帮助你构建完整的模型评估体系。读完本文，你将能够：

精确计算并解释三大评估指标
识别准确率陷阱并选择合适指标
使用混淆矩阵进行错误分析
在D2L框架中实现自定义评估流程

一、混淆矩阵：评估指标的基础

1.1 混淆矩阵（Confusion Matrix）定义

混淆矩阵（Confusion Matrix）是二分类问题中所有评估指标的计算基础，它以矩阵形式展示模型预测结果与真实标签的对应关系。对于二分类问题，混淆矩阵为2×2矩阵，包含四个核心元素：

真实标签\预测结果	正例（Positive）	负例（Negative）
正例（Positive）	真正例（TP）	假负例（FN）
负例（Negative）	假正例（FP）	真负例（TN）

其中：

真正例（True Positive, TP）：真实标签为正例且预测正确
假正例（False Positive, FP）：真实标签为负例但预测为正例（I型错误）
假负例（False Negative, FN）：真实标签为正例但预测为负例（II型错误）
真负例（True Negative, TN）：真实标签为负例且预测正确

1.2 混淆矩阵的数学意义

混淆矩阵本质上是一个条件概率矩阵，每个元素代表特定预测结果的概率：

TP率 = P(预测正例 | 真实正例)
FP率 = P(预测正例 | 真实负例)
FN率 = P(预测负例 | 真实正例)
TN率 = P(预测负例 | 真实负例)

二、核心评估指标详解

2.1 准确率（Accuracy）

定义与公式

准确率（Accuracy，ACC）是最直观的评估指标，表示模型预测正确的样本占总样本的比例：

\text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN}

代码实现（D2L框架）

def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)  # 返回每行中最大值的索引
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

# 计算准确率
def evaluate_accuracy(net, data_iter):
    """计算在指定数据集上模型的准确率"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

应用场景与局限性

适用场景：均衡分布的数据集，如MNIST数字识别。 局限性：

对不平衡数据敏感：在欺诈检测中（99%为正常交易），简单预测全部为正常即可达到99%准确率
无法区分错误类型：无法判断错误是FP还是FN

2.2 精确率与召回率

精确率（Precision）

定义：精确率（Precision，查准率）表示预测为正例的样本中，真正为正例的比例：

\text{Precision} = \frac{TP}{TP + FP}

代码实现：

def precision(y_hat, y):
    """计算精确率"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    tp = ((y_hat == 1) & (y == 1)).sum().item()
    fp = ((y_hat == 1) & (y == 0)).sum().item()
    return tp / (tp + fp) if (tp + fp) > 0 else 0.0

召回率（Recall）

定义：召回率（Recall，查全率）表示真实为正例的样本中，被成功预测的比例：

\text{Recall} = \frac{TP}{TP + FN}

代码实现：

def recall(y_hat, y):
    """计算召回率"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    tp = ((y_hat == 1) & (y == 1)).sum().item()
    fn = ((y_hat == 0) & (y == 1)).sum().item()
    return tp / (tp + fn) if (tp + fn) > 0 else 0.0

精确率-召回率权衡

精确率和召回率通常存在权衡关系，提高精确率往往会降低召回率，反之亦然。这种关系可以通过PR曲线（Precision-Recall Curve）可视化：

mermaid

2.3 F1分数（F1-Score）

定义与公式

F1分数是精确率和召回率的调和平均数，用于综合评价模型性能：

F1 = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}}

调和平均相比算术平均更侧重较小值，因此F1分数低表明精确率或召回率有明显短板。

代码实现

def f1_score(y_hat, y):
    """计算F1分数"""
    p = precision(y_hat, y)
    r = recall(y_hat, y)
    return 2 * p * r / (p + r) if (p + r) > 0 else 0.0

多类别扩展

对于多类别分类问题，F1分数有三种计算方式：

宏平均（Macro-average）：对每个类别计算F1后取算术平均
微平均（Micro-average）：先计算总体的TP、FP、FN，再计算F1
加权平均（Weighted-average）：按类别样本数加权计算F1

def multiclass_f1(y_hat, y, average='weighted'):
    """多类别F1分数计算"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    
    classes = torch.unique(y)
    f1_scores = []
    weights = []
    
    for cls in classes:
        tp = ((y_hat == cls) & (y == cls)).sum().item()
        fp = ((y_hat == cls) & (y != cls)).sum().item()
        fn = ((y_hat != cls) & (y == cls)).sum().item()
        
        p = tp / (tp + fp) if (tp + fp) > 0 else 0.0
        r = tp / (tp + fn) if (tp + fn) > 0 else 0.0
        f1 = 2 * p * r / (p + r) if (p + r) > 0 else 0.0
        
        f1_scores.append(f1)
        if average == 'weighted':
            weights.append((y == cls).sum().item())
    
    if average == 'macro':
        return sum(f1_scores) / len(f1_scores)
    elif average == 'weighted':
        return sum(w * f for w, f in zip(weights, f1_scores)) / sum(weights)
    else:  # micro
        total_tp = ((y_hat == y)).sum().item()
        total = len(y)
        return total_tp / total if total > 0 else 0.0

三、指标选择策略

3.1 场景驱动的指标选择

不同应用场景对评估指标有不同要求：

应用场景	核心指标	原因
垃圾邮件检测	精确率	避免正常邮件被误判（FP代价高）
癌症筛查	召回率	尽量找出所有患者（FN代价高）
推荐系统	F1分数	平衡相关性和覆盖率
异常检测	F1分数	数据极度不平衡时的综合评价

3.2 准确率陷阱案例分析

案例：欺诈交易检测（99%为正常交易）

模型A：预测全部为正常交易，准确率=99%，但无法检测任何欺诈
模型B：准确率=95%，但精确率=80%，召回率=70%，F1=74.4%

显然模型B更实用，这表明在不平衡数据中，准确率会掩盖模型的真实性能。

mermaid

四、D2L框架中的评估实践

4.1 完整评估流程实现

class ClassificationMetrics:
    """分类任务评估指标计算类"""
    def __init__(self):
        self.tp = 0
        self.tn = 0
        self.fp = 0
        self.fn = 0
        
    def update(self, y_hat, y):
        """更新混淆矩阵统计"""
        if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
            y_hat = y_hat.argmax(axis=1)  # 多类别转为类别索引
        y_hat = y_hat.type(y.dtype)
        
        self.tp += ((y_hat == 1) & (y == 1)).sum().item()
        self.tn += ((y_hat == 0) & (y == 0)).sum().item()
        self.fp += ((y_hat == 1) & (y == 0)).sum().item()
        self.fn += ((y_hat == 0) & (y == 1)).sum().item()
        
    def accuracy(self):
        """计算准确率"""
        total = self.tp + self.tn + self.fp + self.fn
        return (self.tp + self.tn) / total if total > 0 else 0.0
        
    def precision(self):
        """计算精确率"""
        return self.tp / (self.tp + self.fp) if (self.tp + self.fp) > 0 else 0.0
        
    def recall(self):
        """计算召回率"""
        return self.tp / (self.tp + self.fn) if (self.tp + self.fn) > 0 else 0.0
        
    def f1(self):
        """计算F1分数"""
        p = self.precision()
        r = self.recall()
        return 2 * p * r / (p + r) if (p + r) > 0 else 0.0
        
    def report(self):
        """生成完整评估报告"""
        return {
            '准确率': f"{self.accuracy():.4f}",
            '精确率': f"{self.precision():.4f}",
            '召回率': f"{self.recall():.4f}",
            'F1分数': f"{self.f1():.4f}",
            '混淆矩阵': {
                'TP': self.tp, 'TN': self.tn,
                'FP': self.fp, 'FN': self.fn
            }
        }

# 使用示例
metrics = ClassificationMetrics()
for X, y in test_iter:
    y_hat = net(X)
    metrics.update(y_hat, y)
print("评估报告:", metrics.report())

4.2 混淆矩阵可视化分析

import matplotlib.pyplot as plt
import seaborn as sns

def plot_confusion_matrix(metrics, class_names=['负例', '正例']):
    """绘制混淆矩阵热图"""
    cm = [
        [metrics.tn, metrics.fp],
        [metrics.fn, metrics.tp]
    ]
    
    plt.figure(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
                xticklabels=class_names, yticklabels=class_names)
    plt.xlabel('预测标签')
    plt.ylabel('真实标签')
    plt.title('混淆矩阵')
    plt.savefig('confusion_matrix.png')  # 保存图像
    plt.close()

# 使用示例
plot_confusion_matrix(metrics)

四、D2L评估工具扩展

4.1 自定义评估指标集成

D2L框架支持通过Accumulator类扩展自定义评估指标：

from d2l import torch as d2l

class MetricsAccumulator(d2l.Accumulator):
    """扩展D2L的Accumulator以支持多指标计算"""
    def __init__(self):
        super().__init__(4)  # tp, tn, fp, fn
        
    def add(self, y_hat, y):
        if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
            y_hat = y_hat.argmax(axis=1)
        y_hat = y_hat.type(y.dtype)
        
        tp = ((y_hat == 1) & (y == 1)).sum().item()
        tn = ((y_hat == 0) & (y == 0)).sum().item()
        fp = ((y_hat == 1) & (y == 0)).sum().item()
        fn = ((y_hat == 0) & (y == 1)).sum().item()
        
        super().add(tp, tn, fp, fn)
        
    @property
    def accuracy(self):
        tp, tn, fp, fn = self.data
        return (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else 0.0
        
    @property
    def precision(self):
        tp, tn, fp, fn = self.data
        return tp / (tp + fp) if (tp + fp) > 0 else 0.0
        
    @property
    def recall(self):
        tp, tn, fp, fn = self.data
        return tp / (tp + fn) if (tp + fn) > 0 else 0.0
        
    @property
    def f1(self):
        p = self.precision
        r = self.recall
        return 2 * p * r / (p + r) if (p + r) > 0 else 0.0

# 在训练循环中集成
def train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs):
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc', 'test f1'])
    metric = d2l.Accumulator(3)  # 训练损失、训练准确率、样本数
    metrics = MetricsAccumulator()
    
    for epoch in range(num_epochs):
        net.train()
        for i, (X, y) in enumerate(train_iter):
            trainer.zero_grad()
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            trainer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % 50 == 0:
                animator.add(epoch + i / len(train_iter),
                            (train_l, train_acc, None, None))
        
        # 计算测试集指标
        metrics.reset()
        net.eval()
        with torch.no_grad():
            for X, y in test_iter:
                y_hat = net(X)
                metrics.add(y_hat, y)
        test_acc = metrics.accuracy
        test_f1 = metrics.f1
        animator.add(epoch + 1, (None, None, test_acc, test_f1))
    
    print(f'最终训练损失: {train_l:.4f}, 训练准确率: {train_acc:.4f}')
    print(f'测试准确率: {test_acc:.4f}, 测试F1分数: {test_f1:.4f}')

五、总结与最佳实践

5.1 核心要点回顾

混淆矩阵是基础：所有评估指标均源于混淆矩阵的四个基本元素
单一指标有局限：准确率在不平衡数据上不可靠，需结合精确率、召回率和F1分数
场景决定指标：根据错误代价选择合适指标（FP vs FN）
可视化辅助分析：PR曲线和混淆矩阵有助于深入理解模型行为

5.2 模型评估 checklist

计算完整混淆矩阵，而非仅关注单一指标
在不同阈值下评估模型性能，绘制PR曲线
对不平衡数据使用分层抽样评估
报告精确率、召回率和F1分数的同时，说明选择主要指标的理由
进行错误分析，识别模型容易混淆的类别

5.3 进阶方向

ROC曲线与AUC指标：适用于不同阈值下的模型比较
多标签分类评估：Hamming损失、微平均与宏平均
回归任务评估：MAE、MSE、RMSE、R²分数
模型校准：Brier分数、校准曲线

通过本文介绍的评估方法，你可以构建更全面的模型评价体系，避免常见的指标误用陷阱，为不同应用场景选择最合适的评估策略。掌握这些技能将显著提升你的深度学习项目落地能力。

若对本文内容有任何疑问或建议，欢迎在评论区留言讨论。关注获取更多D2L深度学习实践指南，下期将带来《超参数调优：网格搜索与贝叶斯优化实战》。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考