AUC性能指标计算方法及优缺点

AUC性能指标计算方法及优缺点

ROC实际评估模型对样本分类预测概率的排名序列，在不同截断点，和实际样本标签之间的差异。通过排序本身的质量好坏体现了学习器的”期望泛化性能“。

ROC曲线通过假阳性率FDR和真阳性率TPR来绘制，所有真实负样本中预测为正的比例FPR=FP/（FP+TN），所有真实正样本中预测为真的比例TPR=TP/(TP+FN)

AUC（Area Under ROC Curve）是ROC下面的面积，AUC越大说明分类器越可能把正样本排在前面。

AUC的优点：

1.衡量排序能力，适合排序类任务

2.对正负样本均衡不敏感，在样本不均衡情况下也能够合理评估

3.AUC不需要手动设置阈值，是一种整体上的衡量方法

AUC的缺点：

1.忽略了预测的概率值和模型的拟合程度

2.AUC反应信息较为笼统，无法反映召回率、精确率等实际业务关心指标

3.没有给出模型误差的空间分布信息，只关心正负样本之间的排序，并不关心正负样本内部的排序，难以衡量样本对于实际程度的刻画能力。

AUC的改进：

AUC仅关注所有样本中模型的排序能力，但是个性化推荐中，我们更关心对于同一个用户模型排序item的能力。因此引入了GAUC，对每个用户算AUC，然后算加权平均。

AUC的计算：

AUC也被定义为：随机抽样过程中，正样本预测值大于负样本预测值的概率。代码如下：

import numpy as np
from sklearn.metrics import roc_auc_score

y = np.array([0,   0,   0,   0,   1,    0,   0,    0,    1,   1  ])
pred = np.array([0.9, 0.4, 0.3, 0.1, 0.6, 0.58, 0.65, 0.32, 0.8, 0.7])

auc = roc_auc_score(y, pred)
print('AUC calculated by sklearn tool is {}'.format(auc))

p_index = []
n_index = []
for i in range(len(y)):
    if(y[i]==0):
        n_index.append(i)
    else:
        p_index.append(i)

total = 0
numerator = 0
for p in p_index:
    for n in n_index:
        total += 1
        if(pred[p]>pred[n]):
            numerator += 1
        if(pred[p]==pred[n]):
            numerator +=0.5

print(numerator/total)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

AUC的计算还可以通过排序从O($n^2$)优化到O(nlogn)，代码如下：

import numpy as np
from sklearn.metrics import roc_auc_score
y = np.array([0,   0,   0,   0,   1,    0,   0,    0,    1,   1  ])
pred = np.array([0.9, 0.4, 0.3, 0.1, 0.6, 0.58, 0.65, 0.32, 0.8, 0.7])

auc = roc_auc_score(y, pred)
print('AUC calculated by sklearn tool is {}'.format(auc))

arr = list(zip(list(pred),list(y)))
arr = sorted(arr,key=lambda x: x[0])
arr = np.array(arr)
M = 0
N = 0
sum = 0
rank = np.arange(1,len(arr)+1,dtype=float)

for index in range(0,len(arr)):
    rank[index] = np.mean(rank[arr[:,0]==arr[index,0]])#返回值相等的索引集合，求平均
    if(arr[index,1]==1):
        sum += rank[index]
        M += 1
    else:
        N += 1

numerator = (sum-(M+1)*M/2)
M_N = M*N
print(numerator/(M*N))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28