多分类评估指标手算指南：TP/FP/FN/TN与TPR/FPR逐类解析

1. 项目概述：多分类场景下，如何真正搞懂并手算每一个核心评估指标？

在实际做模型评估时，很多人一看到“多分类”就直接跳过手动计算环节，转而依赖sklearn.metrics.classification_report里一行输出完事。但问题来了——当你的业务场景里，某个类别错判的代价极高（比如医疗诊断中把“恶性肿瘤”预测成“良性”），或者你正在调试一个新设计的损失函数，需要逐类观察模型的“偏见”分布，这时候，只看一个笼统的macro/micro平均值，根本无法定位问题。我做过二十多个跨行业建模项目，从工业缺陷检测到金融风控，凡是出过线上事故的，八成都栽在对TP/FP/FN/TN这些基础概念的理解偏差上：有人以为多分类的TP就是所有预测正确的样本总和，有人把FPR当成“所有负类中被误判为正类的比例”，却没意识到——在多分类中，“正类”和“负类”的定义是动态的、按类别轮换的。这篇文章不讲API怎么调用，而是带你回到最原始的混淆矩阵本质，用Python从零手推每一个指标：FP、FN、TP、TN到底怎么定义？TPR（召回率）、TNR（特异度）、FPR（误报率）、FNR（漏报率）在三分类、五分类中如何逐类计算？Accuracy为什么在类别不平衡时会严重失真？更重要的是，我会用一个真实的手写数字识别（MNIST子集）案例，展示每一步计算过程、中间矩阵形态、数值来源，甚至包括如何用pandas快速透视、用seaborn可视化每一类的误判流向。无论你是刚学机器学习的学生，还是需要向业务方解释模型风险的数据科学家，只要你需要真正“看懂”模型在每个类别上的表现，而不是只信那一行summary，这篇就是为你写的。

2. 核心思路拆解：为什么不能直接套用二分类公式？多分类评估的本质逻辑

2.1 二分类与多分类评估的根本差异：从“单一对立”到“多维轮换”

二分类评估之所以直观，是因为它只存在一个明确的“正类”（Positive）和一个明确的“负类”（Negative）。TP就是“正类被正确预测”，FP就是“负类被误判为正类”，整个逻辑链条是线性的、静态的。但多分类完全不同——它没有全局唯一的“正类”。当你面对一个5分类任务（比如猫、狗、鸟、鱼、虫），评估任何一个指标，都必须先指定“当前关注的类别”。这个指定动作，就是多分类评估的起点，也是绝大多数人踩坑的第一步。举个具体例子：在猫狗鸟鱼虫分类中，如果你要计算“猫”这个类别的TPR（召回率），那么：

• “猫”就是当前的正类（Positive）；
• 所有其他类别（狗、鸟、鱼、虫）合起来，就是当前的负类（Negative）；
• TP = 真实标签是“猫”且预测也是“猫”的样本数；
• FN = 真实标签是“猫”但预测是“狗/鸟/鱼/虫”中任意一个的样本数；
• FP = 真实标签是“狗/鸟/鱼/虫”中任意一个，但预测是“猫”的样本数；
• TN = 真实标签是“狗/鸟/鱼/虫”中任意一个，且预测也是“狗/鸟/鱼/虫”中任意一个的样本数（注意：这里TN不是“非猫”的全部正确预测，而是“非猫”中被正确预测为“非猫”的部分，即预测≠猫且真实≠猫）。

这个逻辑，我称之为“单类聚焦法”。它意味着，对于K个类别的任务，你需要独立计算K次TP、FP、FN、TN，每次只聚焦一个类别作为正类，其余K-1类共同构成负类。这直接导致了后续所有衍生指标（TPR、FPR等）也必须是K维向量，而非单一标量。很多初学者直接拿二分类公式套用，比如用TP / (TP + FP)去算整个数据集的FPR，结果得到一个毫无业务意义的数字——因为TP和FP在这里根本不在同一个“正类定义”下统计，它们是不同轮次计算出来的，强行相加等于把苹果和橙子混在一起称重。

2.2 为什么Accuracy在多分类中常常是个“温柔的陷阱”？

Accuracy（准确率）= (TP + TN) / 总样本数，在二分类中是一个简洁有力的指标。但在多分类中，它的分母是固定的（总样本数），分子却是所有类别TP之和加上所有类别TN之和。问题在于，TN的量级会随着类别数K的增加而爆炸式增长。假设你有一个10分类任务，其中9个类别各只有10个样本，第10个类别有910个样本（典型的长尾分布）。模型如果把所有样本都预测为第10类，Accuracy会高达91%（910/1000），看起来很优秀。但事实上，其余9个类别的召回率全部为0！这就是Accuracy的致命缺陷：它用一个全局平均掩盖了局部灾难。我在一个电商推荐项目中就遇到过类似情况：模型整体Accuracy 85%，但“高价值用户流失预警”这个关键类别TPR只有12%，业务方完全无法接受。后来我们果断弃用Accuracy，转而用每个类别的F1-score加权平均，并强制要求关键类别的TPR不低于60%。所以，Accuracy在多分类中，只能作为最粗粒度的参考，绝不能作为核心优化目标或验收标准。真正有价值的，永远是按类分解的指标，尤其是TPR（召回率）和FPR（误报率），它们直接对应业务中的“漏检成本”和“误杀成本”。

2.3 工具选型逻辑：为什么坚持手写计算，而不是全靠sklearn？

sklearn.metrics提供了confusion_matrix、classification_report、precision_recall_fscore_support等成熟工具，为什么还要花时间手写？原因有三：第一，可解释性。classification_report默认输出macro/micro平均，但如果你需要知道“模型把多少个‘3’误判成了‘8’”，就必须深入混淆矩阵内部。第二，可控性。某些特殊场景需要自定义逻辑，比如在医学影像中，“3”和“8”的误判代价远高于“3”和“0”，这时你需要加权FPR，而sklearn原生不支持。第三，教学价值。我带过不少实习生，发现只要让他们手写一次完整的混淆矩阵构建过程，对评估指标的理解深度立刻提升一个量级。所以本文的代码实现，会采用“底层numpy+pandas构建+sklearn验证”的双轨模式：先用最基础的数组操作，一行一行地把TP、FP、FN、TN算出来，再用sklearn的结果交叉验证，确保每一步都透明、可追溯。这种做法看似笨拙，但能让你彻底摆脱“黑箱调包”的依赖，真正掌握评估的主动权。

3. 核心细节解析：从混淆矩阵到每个指标的数学定义与物理含义

3.1 混淆矩阵（Confusion Matrix）：多分类评估的基石与真相之源

混淆矩阵是所有评估指标的源头活水。对于K分类任务，它的形状是K×K的方阵。矩阵的行代表真实标签（True Label），列代表预测标签（Predicted Label）。位置(i, j)上的数值，表示真实为第i类、但被预测为第j类的样本数量。以一个简化的3分类（A、B、C）为例，其混淆矩阵如下：

这个表格本身已经包含了全部信息。现在，我们来逐个提取每个类别的核心四元组：

• 对于类别A（i=0）：
  • TP_A = 矩阵[0][0] = 85（真实A，预测A）
  • FN_A = 矩阵[0][1] + 矩阵[0][2] = 10 + 5 = 15（真实A，但预测B或C）
  • FP_A = 矩阵[1][0] + 矩阵[2][0] = 3 + 2 = 5（真实B或C，但预测A）
  • TN_A = 矩阵[1][1] + 矩阵[1][2] + 矩阵[2][1] + 矩阵[2][2] = 92 + 5 + 8 + 90 = 195（真实B或C，且预测B或C）

提示：TN的计算最容易出错。它不是“非A类别的总样本数减去FP_A”，而是“所有非A真实样本中，被正确预测为非A的数量”。换句话说，TN_A = 总样本数 - (TP_A + FN_A + FP_A)。你可以用这个公式快速验算：总样本数 = 85+10+5+3+92+5+2+8+90 = 300；TP_A+FN_A+FP_A = 85+15+5 = 105；300-105 = 195，与上面结果一致。

3.2 四大基础指标（TP/FP/FN/TN）的逐类计算方法与代码实现

理解了混淆矩阵的结构，计算就变成了纯粹的索引操作。下面我用Python（numpy）给出一个通用的、可复用的函数，它接收真实标签y_true和预测标签y_pred，返回一个字典，包含每个类别的TP、FP、FN、TN：

import numpy as np from collections import defaultdict def calculate_per_class_metrics(y_true, y_pred): """ 计算多分类中每个类别的TP, FP, FN, TN :param y_true: 真实标签列表或numpy数组，shape=(n_samples,) :param y_pred: 预测标签列表或numpy数组，shape=(n_samples,) :return: dict, key为类别名，value为包含TP/FP/FN/TN的字典 """ # 获取所有唯一类别，并排序以保证顺序一致 classes = sorted(set(y_true) | set(y_pred)) n_classes = len(classes) class_to_idx = {cls: i for i, cls in enumerate(classes)} # 构建混淆矩阵 cm = np.zeros((n_classes, n_classes), dtype=int) for true, pred in zip(y_true, y_pred): i = class_to_idx[true] j = class_to_idx[pred] cm[i, j] += 1 # 初始化结果字典 metrics = {} # 对每个类别进行计算 for idx, cls in enumerate(classes): # TP: 对角线元素 tp = cm[idx, idx] # FN: 当前行的和减去TP（所有真实为cls但预测错误的） fn = cm[idx, :].sum() - tp # FP: 当前列的和减去TP（所有预测为cls但真实错误的） fp = cm[:, idx].sum() - tp # TN: 总样本数减去TP、FN、FP total = cm.sum() tn = total - tp - fn - fp metrics[cls] = {'TP': tp, 'FP': fp, 'FN': fn, 'TN': tn} return metrics, cm # 示例使用 y_true = [0, 0, 0, 1, 1, 1, 2, 2, 2] y_pred = [0, 0, 1, 1, 1, 2, 2, 2, 0] metrics, cm = calculate_per_class_metrics(y_true, y_pred) print("混淆矩阵:\n", cm) for cls, m in metrics.items(): print(f"类别 {cls}: TP={m['TP']}, FP={m['FP']}, FN={m['FN']}, TN={m['TN']}")

这段代码的核心思想非常朴素：先建矩阵，再按行/列求和。它不依赖任何高级库，逻辑清晰，便于调试。你可以在任何项目中直接复制粘贴，只需传入你的y_true和y_pred即可。我特别强调“排序set”这一步，是因为如果类别是字符串（如'cat', 'dog'），直接用np.unique可能打乱顺序，导致索引错位。用sorted(set(...))能保证每次运行结果一致，这是工程实践中一个微小但关键的稳定性保障。

3.3 衍生指标（TPR/TNR/FPR/FNR/Accuracy）的定义、公式与业务映射

有了TP/FP/FN/TN，所有衍生指标都是简单的分数运算。但它们的业务含义，才是你真正需要刻进DNA里的东西：

• TPR（True Positive Rate，召回率/敏感度）= TP / (TP + FN)
  物理含义：在所有“真正属于该类”的样本中，模型成功找出了多少？
  业务映射：在疾病筛查中，这是“不漏诊”的能力；在垃圾邮件识别中，这是“不放过一封垃圾邮件”的能力。TPR低，意味着大量真实正例被遗漏，业务风险极高。

• TNR（True Negative Rate，特异度）= TN / (TN + FP)
  物理含义：在所有“真正不属于该类”的样本中，模型正确排除了多少？
  业务映射：在疾病筛查中，这是“不误诊”的能力；在信用评分中，这是“不误拒优质客户”的能力。TNR低，意味着大量负例被误伤，用户体验受损。

• FPR（False Positive Rate，误报率）= FP / (FP + TN) = 1 - TNR
  物理含义：在所有“真正不属于该类”的样本中，模型错误地将其判定为该类的比例。
  业务映射：这是TNR的镜像，常用于ROC曲线绘制。FPR高，意味着模型过于“激进”，宁可错杀一千，不可放过一个。

• FNR（False Negative Rate，漏报率）= FN / (FN + TP) = 1 - TPR
  物理含义：在所有“真正属于该类”的样本中，模型错误地将其判定为其他类的比例。
  业务映射：这是TPR的镜像，直接反映“漏网之鱼”的比例。FNR高，是业务上最不能容忍的。

• Accuracy（准确率）= (TP + TN) / 总样本数
  物理含义：模型整体预测正确的比例。
  业务映射：仅适用于类别极度均衡的场景。一旦失衡，它就是一个极具误导性的数字。

注意：以上所有公式的分母，都必须是针对当前类别计算出来的TP+FN或FP+TN等，绝对不能是全局总和。这是新手最容易犯的错误。

4. 实操过程：用MNIST手写数字数据集，完整演示从数据加载到指标手算的每一步

4.1 数据准备与模型训练：构建一个真实的、可复现的实验环境

为了确保演示的真实性和可复现性，我们选用经典的MNIST数据集，并只取其中的0、1、2三个数字，构建一个3分类任务。这样既能体现多分类特性，又不会因类别过多而让计算过程过于冗长。我们将使用一个轻量级的全连接神经网络（MLP）进行训练，而不是复杂的CNN，目的是让焦点始终集中在评估环节，而非模型架构本身。

import numpy as np import pandas as pd from sklearn.datasets import fetch_openml from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.neural_network import MLPClassifier from sklearn.metrics import confusion_matrix, classification_report # 1. 加载MNIST数据集（仅取数字0,1,2） print("正在加载MNIST数据集...") mnist = fetch_openml('mnist_784', version=1, as_frame=False, parser='auto') X, y = mnist.data, mnist.target # 筛选出0,1,2 mask = np.isin(y, ['0', '1', '2']) X = X[mask].astype('float32') y = y[mask] # 将标签转换为整数 y = np.array([int(label) for label in y]) # 2. 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) # 3. 标准化（MLP对尺度敏感） scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # 4. 训练一个简单的MLP print("正在训练MLP模型...") mlp = MLPClassifier( hidden_layer_sizes=(128,), activation='relu', solver='adam', alpha=0.0001, max_iter=20, random_state=42, verbose=True ) mlp.fit(X_train_scaled, y_train) # 5. 进行预测 y_pred = mlp.predict(X_test_scaled) print("模型训练与预测完成。")

这段代码完成了从数据获取、清洗、划分、预处理到模型训练的全流程。关键点在于stratify=y参数，它确保了训练集和测试集中0、1、2三个数字的比例保持一致，避免了因数据划分不均而导致的评估偏差。max_iter=20是为了控制训练时间，毕竟我们的重点不是模型性能，而是评估过程。运行后，你会看到模型在测试集上的整体Accuracy大约在95%左右，这是一个合理且有挑战性的基线。

4.2 手动计算：用上一节的函数，逐行解析每个类别的TP/FP/FN/TN

现在，我们把上一节编写的calculate_per_class_metrics函数应用到这个真实的MNIST子集上：

# 调用手动计算函数 metrics, cm = calculate_per_class_metrics(y_test, y_pred) # 打印混淆矩阵（美化版） cm_df = pd.DataFrame(cm, index=['True_0', 'True_1', 'True_2'], columns=['Pred_0', 'Pred_1', 'Pred_2']) print("\n=== 混淆矩阵（详细版）===") print(cm_df) # 打印每个类别的四大基础指标 print("\n=== 每个类别的TP/FP/FN/TN ===") for cls in sorted(metrics.keys()): m = metrics[cls] print(f"类别 {cls}: TP={m['TP']:4d} | FP={m['FP']:4d} | FN={m['FN']:4d} | TN={m['TN']:4d}") # 计算并打印每个类别的衍生指标 print("\n=== 每个类别的衍生指标（TPR/TNR/FPR/FNR/Accuracy）===") for cls in sorted(metrics.keys()): m = metrics[cls] tp, fp, fn, tn = m['TP'], m['FP'], m['FN'], m['TN'] total = tp + fp + fn + tn tpr = tp / (tp + fn) if (tp + fn) > 0 else 0 tnr = tn / (tn + fp) if (tn + fp) > 0 else 0 fpr = fp / (fp + tn) if (fp + tn) > 0 else 0 fnr = fn / (fn + tp) if (fn + tp) > 0 else 0 acc = (tp + tn) / total if total > 0 else 0 print(f"类别 {cls}: TPR={tpr:.3f} | TNR={tnr:.3f} | FPR={fpr:.3f} | FNR={fnr:.3f} | Acc={acc:.3f}")

运行这段代码，你会得到类似如下的输出（具体数值会因随机种子略有浮动）：

=== 混淆矩阵（详细版）=== Pred_0 Pred_1 Pred_2 True_0 962 5 13 True_1 12 945 13 True_2 11 12 957 === 每个类别的TP/FP/FN/TN === 类别 0: TP= 962 | FP= 23 | FN= 18 | TN=1887 类别 1: TP= 945 | FP= 17 | FN= 28 | TN=1900 类别 2: TP= 957 | FP= 25 | FN= 23 | TN=1885 === 每个类别的衍生指标（TPR/TNR/FPR/FNR/Accuracy）=== 类别 0: TPR=0.982 | TNR=0.988 | FPR=0.012 | FNR=0.018 | Acc=0.984 类别 1: TPR=0.970 | TNR=0.991 | FPR=0.009 | FNR=0.030 | Acc=0.983 类别 2: TPR=0.977 | TNR=0.987 | FPR=0.013 | FNR=0.023 | Acc=0.984

这个输出信息量极大。首先，混淆矩阵清晰地展示了模型的“误判流向”：例如，真实为0的样本中，有5个被误判为1，13个被误判为2；而真实为1的样本中，有12个被误判为0，13个被误判为2。其次，四大基础指标揭示了模型在每个类别的“基本功”：类别0的TP最高（962），FN最低（18），说明它最容易被识别；类别1的FN最高（28），说明它相对最难区分。最后，衍生指标给出了更精细的评价：所有类别的TPR都在0.97以上，说明模型“找得准”；TNR都在0.987以上，说明模型“排得清”。但请注意，每个类别的Accuracy（0.983~0.984）与整体Accuracy（约0.983）几乎一致，这是因为三个类别样本量非常均衡（各约600个），所以Accuracy此时是有效的。如果换成0、1、8三个数字，结果就会大不相同。

4.3 可视化分析：用热力图和条形图，让指标“说话”

数字是冰冷的，图表是温暖的。为了让评估结果更具洞察力，我们用seaborn绘制混淆矩阵热力图，并用matplotlib绘制每个类别的TPR/TNR对比条形图：

import seaborn as sns import matplotlib.pyplot as plt # 1. 绘制混淆矩阵热力图 plt.figure(figsize=(8, 6)) sns.heatmap(cm_df, annot=True, fmt='d', cmap='Blues', cbar=False) plt.title('Confusion Matrix (0, 1, 2)') plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.show() # 2. 绘制每个类别的TPR和TNR对比图 classes = sorted(metrics.keys()) tpr_list = [] tnr_list = [] for cls in classes: m = metrics[cls] tp, fp, fn, tn = m['TP'], m['FP'], m['FN'], m['TN'] tpr = tp / (tp + fn) if (tp + fn) > 0 else 0 tnr = tn / (tn + fp) if (tn + fp) > 0 else 0 tpr_list.append(tpr) tnr_list.append(tnr) x = np.arange(len(classes)) width = 0.35 fig, ax = plt.subplots(figsize=(8, 6)) rects1 = ax.bar(x - width/2, tpr_list, width, label='TPR (Recall)', color='skyblue') rects2 = ax.bar(x + width/2, tnr_list, width, label='TNR (Specificity)', color='lightcoral') ax.set_xlabel('Class') ax.set_ylabel('Rate') ax.set_title('TPR and TNR by Class') ax.set_xticks(x) ax.set_xticklabels([f'Class {c}' for c in classes]) ax.legend() ax.grid(axis='y', alpha=0.3) # 在柱子上添加数值标签 def add_labels(rects): for rect in rects: height = rect.get_height() ax.annotate(f'{height:.3f}', xy=(rect.get_x() + rect.get_width() / 2, height), xytext=(0, 3), # 3 points vertical offset textcoords="offset points", ha='center', va='bottom') add_labels(rects1) add_labels(rects2) plt.tight_layout() plt.show()

热力图直观地暴露了模型的“薄弱环节”：颜色越深（蓝色越浓）的地方，表示该单元格数值越大，即该类别的预测越准确；颜色越浅（接近白色）的地方，则是误判的高发区。从图中可以一眼看出，对角线（正确预测）区域最深，而“0→2”、“1→2”等非对角线区域相对较浅，说明模型在区分0、1与2时存在轻微困难。条形图则将TPR和TNR放在同一坐标系下对比，清晰地显示出：对于类别0，TPR（0.982）略高于TNR（0.988）；而对于类别1，TPR（0.970）明显低于TNR（0.991），这意味着模型在“找”类别1时稍显保守，宁可漏掉一些，也不愿误判。这种细粒度的洞察，是任何一行classification_report都无法提供的。

5. 常见问题与排查技巧实录：那些只有亲手算过才会懂的坑

5.1 常见问题速查表：从报错到逻辑谬误的全场景覆盖

5.2 我踩过的坑：关于类别不平衡与指标选择的血泪教训

在我负责的一个工业质检项目中，我们需要识别产品表面的划痕（Scratch）、凹坑（Dent）和正常（OK）三类。其中，OK样本占95%，Scratch仅占3%，Dent占2%。模型训练后，accuracy_score高达0.95，看起来完美。但当我手动计算每个类别的TPR时，发现Scratch的TPR只有0.12，Dent的TPR只有0.08。这意味着，90%以上的缺陷都被漏掉了！当时团队差点就上线了这个“高准确率”模型。后来我们紧急调整了策略：

1. 放弃Accuracy，改用Macro-F1：F1-score是TPR和Precision的调和平均，对少数类更敏感。
2. 为少数类设置更高的分类权重：在MLPClassifier中加入class_weight='balanced'参数，让模型在训练时更关注Scratch和Dent的损失。
3. 引入阈值调优：对模型的原始输出（logits）进行sigmoid后，不直接argmax，而是设定一个动态阈值，对Scratch类别的预测概率要求更高。

经过这三步调整，Scratch的TPR从0.12提升到了0.78，虽然整体Accuracy降到了0.89，但业务方完全接受，因为他们的核心诉求是“不漏检”，而不是“整体猜得准”。这个教训让我深刻体会到：评估指标的选择，永远应该由业务目标驱动，而不是由技术便利性驱动。Accuracy就像一个漂亮的包装盒，而TPR/TNR才是盒子里真正的东西。永远不要被那个漂亮的数字迷惑。

5.3 实操心得：提升效率与可靠性的5个独家技巧

1. 技巧一：用pandas的crosstab替代手写混淆矩阵
   对于快速探索，pd.crosstab(y_true, y_pred)比sklearn.metrics.confusion_matrix更直观，它直接返回一个DataFrame，行列名清晰可见，无需自己构建索引映射。“pd.crosstab(y_test, y_pred, rownames=['True'], colnames=['Pred'])”一行搞定，适合在Jupyter中快速查看。

2. 技巧二：封装一个“评估仪表盘”函数
   把所有计算逻辑打包成一个函数，输入y_true/y_pred，输出一个包含所有指标的DataFrame。这样，你可以在不同模型、不同数据集上一键跑通，横向对比。我的模板函数会返回一个MultiIndex DataFrame，第一层是类别，第二层是指标名（TPR, FPR...），方便后续用df.unstack()做各种聚合。

3. 技巧三：为关键类别设置“红绿灯”阈值
   在生产环境中，我习惯为每个关键类别设定TPR和FPR的阈值（如TPR≥0.8, FPR≤0.1），并在评估报告中用颜色标注：绿色（达标）、黄色（警告）、红色（失败）。这能让非技术人员一眼看懂模型健康状况。

4. 技巧四：用“误判流向图”替代静态混淆矩阵
   对于超过5个类别的任务，混淆矩阵会变得难以阅读。此时，我用networkx绘制一个有向图，节点是类别，边的粗细代表误判数量。这样，模型的“混淆路径”一目了然，比如“模型总是把A和B搞混”，这种模式在矩阵里可能被淹没，但在图中会非常突出。

5. 技巧五：永远保留一份“原始预测日志”
   在模型上线前，我一定会保存一份y_true和y_pred的原始数组（或存入数据库）。这样，当线上指标异常时，我可以随时回溯，用同样的手写函数重新计算，精准定位是数据漂移、模型退化，还是评估代码本身出了bug。这份日志，是模型可解释性的最后一道防线。

6. 进阶思考：当多分类遇上更复杂的现实——层次化分类与多标签

6.1 层次化分类（Hierarchical Classification）中的指标计算

现实世界的问题往往不是扁平的。比如，动物分类可以是：哺乳动物→猫科→家猫；鸟类→雀形目→麻雀。在这种层次化结构中，“猫”和“麻雀”不再是平级的兄弟，而是位于不同分支的节点。此时，传统的“单类聚焦法”就失效了。一个更合理的做法是：定义“祖先正确”和“后代正确”。例如，如果真实标签是“家猫”，而模型预测为“猫科”，这不算完全错误，而是一种“粗粒度正确”。计算TPR时，可以定义：TP = 预测标签是真实标签的祖先或自身。这需要你预先定义好类别树（taxonomy），并在计算时进行DFS/BFS遍历。虽然复杂度上升，但它让指标更贴近人类认知。

6.2 多标签分类（Multi-Label Classification）的范式转移

多标签与多分类有本质区别：多分类是“单选题”（一个样本只能属于一个类别），而多标签是“多选题”（一个样本可以同时属于猫和宠物）。此时，TP/FP/FN/TN的定义必须重构。最常用的是“样本级”和“标签级”两种视角：

• 样本级：一个样本只有在所有标签都预测正确时，才算TP；只要有一个标签错了，就算FP或FN。这要求极高，适合对完整性要求严苛的场景。
• 标签级：对每个标签单独计算TP/FP/FN，就像我们前面做的多分类一样，只是这里的“正