如何减少代码行并使其与其他数据一起使用？

Question

我有这样的多类：

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]

我想找到每个类的精度（0,1,2）

这是我的代码：

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)

如果我以前知道类和数据的数量，它就可以工作。 但现在无论我是否认识他们，我都想让它发挥作用，就像我有更多的课程一样。

如何减少代码或使其动态化？

注意：我不喜欢用图书馆来完成它。

Answer 1

你可以试试这个：

from collections import defaultdict

def precision(y_test, y_pred): 
    # to count false-pos and true-pos  
    tp = defaultdict(int)
    fp = defaultdict(int)
    classes = max(max(y_test), max(y_pred)) 
    
    # count tp and fp
    for i in range(len(y_pred)):
        if y_pred[i] == y_test[i]:
            tp[y_test[i]] += 1
        else:
            fp[y_test[i]] += 1
    
    # calculate prec for every class
    precision = dict()
    for cls in range(classes+1):
        precision[cls] = tp[cls] / (tp[cls] + fp[cls])
    
    return precision


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

Output：

{0: 0.5, 1: 0.5, 2: 0.5, 3: 0.0}

您将获得带有键的字典 - class 和值 - 精度。

Answer 2

import numpy as np

# Convert to arrays
y_pred = np.array(y_pred)
y_test = np.array(y_test)

def get_precision(pred, truth, num_classes):
    precision_by_class = []
    match = (pred == truth) # Binary array indicating whether each prediction is true
    for i_class in range(num_classes): # Iterate over classes
        # match[pred == i_class].sum() -> number of correct predictions of specific class
        # (pred == i_class).sum() -> number of times specific class was predicted
        out.append(match[pred == i_class].sum() / (pred == i_class).sum())
    accuracy = match.mean() # Total accuracy
    return precision_by_class, accuracy