AUC两种计算方式

1.通过ROC曲线面积计算AUC

AUC（Area Under Curve）被定义为ROC曲线下的面积。

ROC 曲线横坐标：假正率=FPR=FP/N：  预测为负 and 实际为正 / 实际为负

ROC 曲线纵坐标：真正率=TPR= TP/P ：预测为正 and 实际为正 / 实际为正

 注意:有相同预估值时，需要等当前预估值作为阈值的所有 tp,fp 算完，再更新最终 auc

def calcAUC_byRocArea(label,pred):
    P = 0.0
    N = 0.0
    TP = 0.0
    FP = 0.0
    TPR = 0.0
    FPR = 0.0
    LAST_TRP = 0.0
    LAST_FPR = 0.0
    auc = 0.0
    for l in label:
        if l == 0:
            N+=1
        else:
            P+=1
    sample = zip(label,pred)
    sample_sorted = sorted(sample,key=lambda x: -x[1])


    for i,info in enumerate(sample_sorted):
        l,p = info
        if l == 1:
            TP+=1
        else:
            FP+=1
     
        if i !=0 and  i+1 < len(sample) and p == sample_sorted[i+1][1]:
            continue
        
        TPR = TP/P
        FPR = FP/N
        auc+=0.5*(TPR+LAST_TRP)*(FPR-LAST_FPR)
        LAST_FPR=FPR
        LAST_TRP=TPR

    return auc

　　

2.通过计算概率计算AUC

AUC还有一种解释就是任取一对正负样本，正样本的预测值大于负样本的预测值的概率。

2.1 暴力 时间复杂度 o(n2)

（1）遍历 label, 选出正样本、负样本。

（2）遍历正负样本 pair，记录正样本 pred> 负样本 pred 的个数为 cnt

（3） auc = cnt / 正样本个数* 负样本个数。

from sklearn.metrics import roc_auc_score
import numpy as np

def calcAUC_byProb(label,pred):
    pos_porb = []
    neg_prob = []
    for i in range(len(label)):
        if label[i] == 1:
            pos_porb.append(pred[i])
        elif label[i] == 0:
            neg_prob.append(pred[i])
    cnt = 0.0
    for p in pos_porb:
        for n in neg_prob:
            if (p>n):
                cnt+=1
            elif(p == n):
                cnt+=0.5
    return cnt / float(len(pos_porb)*len(neg_prob))

y = np.array([1, 1, 1, 0,0])
pred = np.array([0.6,0.3, 0.5 ,0.2,0.4])
print("sklearn auc:",roc_auc_score(y, pred))
#print("my auc calc by area:", calcAUC_byRocArea(y, pred))
print("my auc calc by prob:", calcAUC_byProb(y, pred))

2.2 动态规划，时间复杂度0（nlogn)

（1）按照预估值降序，组成 pair。

（2)遍历pair, 如果 label==1，记录正样本个数 pos,

如果 label==0， 对于当前样本来说，前面所有的正样本个数pos就是 当前样本与所有正样本预估值大于当前负样本预估值的个数。

（3）auc = pos / (pos *n-pos)

def calcAUC_byProb(label,pred):
    sample = zip(label,pred)
    sample_sorted = sorted(sample,key=lambda x: -x[1])
    pos = 0
    cnt = 0
    last_pred = 0
    print(sample_sorted)
    for i in range(len(sample_sorted)):
        l,p = sample_sorted[i]
        if l == 1:
            pos+=1
        elif l == 0:
            cnt += pos
            if (i!=0 and last_pred ==p):
                cnt-=0.5
        last_pred = p
    negs = len(label) - pos
    print (cnt,pos,negs)
    return float(cnt) / float(pos*negs)