如何精简代码并实现多类别precision计算的动态适配？

输入数据 #

predicted = [1, 0, 2, 1, 1, 0, 1, 2, 1, 2, 2, 0, 0, 0, 0, 2, 2, 1, 1, 1, 0, 1, 0, 1, 2, 1, 1, 2, 0, 0]
actual    = [1, 0, 2, 1, 1, 0, 1, 2, 1, 1, 2, 0, 0, 0, 0, 1, 2, 1, 1, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0]

需求说明 #

需要计算每个类别的Precision，现有代码仅能适配固定数量的类别，需修改为适配任意类别数量且不依赖第三方库的实现。

原始实现（仅适配固定类别） #

TP_0 = 0
TP_1 = 0
TP_2 = 0
FP_0 = 0
FP_1 = 0
FP_2 = 0
    
for i in range(len(y_pred)):
    if y_pred[i] == y_test[i] :
        if y_pred[i] == 0: 
            TP_0 += 1
        elif y_pred[i] == 1:
            TP_1 += 1
        else:
            TP_2 += 1
    else:
        if y_pred[i] == 0: 
            FP_0 += 1
        elif y_pred[i] == 1:
            FP_1 += 1
        else:
            FP_2 += 1 

precision_0 = TP_0/(TP_0+FP_0)
precision_1 = TP_1/(TP_1+FP_1)
precision_2 = TP_2/(TP_2+FP_2)

动态适配的精简实现 #

核心思路 #

1. 从预测值和真实值中自动提取所有唯一类别，无需预先指定
2. 使用字典存储每个类别的TP（真阳性）和FP（假阳性）计数，替代硬编码变量
3. 遍历预测-真实值对，动态更新计数
4. 处理分母为0的边界情况（避免除以0错误）

代码实现 #

predicted = [1, 0, 2, 1, 1, 0, 1, 2, 1, 2, 2, 0, 0, 0, 0, 2, 2, 1, 1, 1, 0, 1, 0, 1, 2, 1, 1, 2, 0, 0]
actual = [1, 0, 2, 1, 1, 0, 1, 2, 1, 1, 2, 0, 0, 0, 0, 1, 2, 1, 1, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0]

# 获取所有唯一类别（覆盖预测和真实中的所有类别）
unique_classes = set(predicted + actual)

# 初始化TP和FP计数字典
tp_counts = {cls: 0 for cls in unique_classes}
fp_counts = {cls: 0 for cls in unique_classes}

# 遍历每一对预测值与真实值
for pred, act in zip(predicted, actual):
    if pred == act:
        tp_counts[pred] += 1
    else:
        fp_counts[pred] += 1

# 计算每个类别的Precision，处理分母为0的情况
precision_results = {}
for cls in unique_classes:
    total_predictions = tp_counts[cls] + fp_counts[cls]
    # 分母为0时返回0（或根据业务需求调整为其他值，如None）
    precision_results[cls] = tp_counts[cls] / total_predictions if total_predictions != 0 else 0.0

# 按类别顺序输出结果
for cls in sorted(unique_classes):
    print(f"类别 {cls} 的Precision: {precision_results[cls]:.4f}")

代码优势 #

• 动态适配：自动识别所有类别，支持任意数量的分类场景
• 简洁易维护：用字典替代硬编码变量，避免重复代码
• 鲁棒性强：处理了分母为0的边界情况，防止运行时错误
• 可读性高：使用zip遍历配对数据，代码逻辑更清晰

内容的提问来源于stack exchange，提问作者Khatcha Reunlek