AUC代码实现

ROC曲线以FPR作为横轴，TPR作为纵轴。AUC值越大，模型越可能将其分类为正样本

• FPR：假阳率
• TPR：真阳率

AUC适合正负样本不均衡的数据集评估，取值范围$[0.5, 1]$

AUC在希望提高Recall的基础上，还希望降低犯错误的概率，尽量不误报，是偏保守的

计算方法1：$O(N^2)$

根据AUC的统计学定义：随机从正负样本中抽取一对正负样本，正样本的预测概率大于负样本预测概率的概率就是AUC。有点拗口，但就是概率的概率。

$$\begin{align} AUC = \frac{\sum (pred_{pos} > pred_{neg})}{m *n} \end{align}$$

用代码来实现就是，在m个正样本，n个负样本的数据集中，对m * n个正样本里，统计正样本预测概率大于负样本的数目，然后除以总数目

def calcAUC_byProb(labels, probs):
    N = 0           # 正样本数量
    P = 0           # 负样本数量
    neg_prob = []   # 负样本的预测值
    pos_prob = []   # 正样本的预测值
    for index, label in enumerate(labels):
        if label == 1: # 正样本数++
            P += 1
            pos_prob.append(probs[index])
        else:
            N += 1  # 负样本数++
            neg_prob.append(probs[index])
    number = 0
    
    for pos in pos_prob: # 遍历正负样本间的两两组合
        for neg in neg_prob:
            if (pos > neg):  # 如果正样本预测值>负样本预测值，正序对数+1
                number += 1
            elif (pos == neg):  # 如果正样本预测值==负样本预测值，算0.5个正序对
                number += 0.5
    return number / (N * P)

计算方法2：$O(log N)$

还有个更好的方法，时间复杂度为$O(logN)$ ，这也是比上面方法更重要的方法。

$$\begin{align} AUC & = \frac{\sum (pred_{pos} > pred_{neg})}{m *n} \\ & = \frac{\sum_{pos} \sum_{neg} (pred_{pos} > pred_{neg})}{m * n} \\ & = \frac{(\sum_{pos} rank_{pos}) - \frac{m * (1 + m)}{2}}{m * n} \\ \end{align}$$

def get_auc(labels, preds):
    # 这段代码基本上是沿着公式计算的：
    # 1. 先求正样本的rank和
    # 2. 再减去（m*(m+1)/2）
    # 3. 最后除以组合个数
    
    # 但是要特别注意，需要对预测值pred相等的情况进行了一些处理。
    # 对于这些预测值相等的样本，它们对应的rank是要取平均的

    # 先将data按照pred进行排序
    sorted_data = sorted(list(zip(labels, preds)), key=lambda item: item[1])
    pos = 0.0       # 正样本个数
    neg = 0.0       # 负样本个数
    auc = 0.0
    # 注意这里的一个边界值，在初始时我们将last_pre记为第一个数，那么遍历到第一个数时只会count++
    # 而不会立刻向结果中累加（因为此时count==0，根本没有东西可以累加）
    last_pre = sorted_data[0][1]
    count = 0.0
    pre_sum = 0.0    # 当前位置之前的预测值相等的rank之和，rank是从1开始的，所以在下面的代码中就是i+1
    pos_count = 0.0  # 记录预测值相等的样本中标签是正的样本的个数
    
    # 为了处理这些预测值相等的样本，我们这里采用了一种lazy计算的策略：
    # 当预测值相等时仅仅累加count，直到下次遇到一个不相等的值时，再将他们一起计入结果
    for i, (label, pred) in enumerate(sorted_data):
        # 注意：rank就是i+1
        if label > 0:
            pos += 1
        else:
            neg += 1
        if last_pre != pred:                    # 当前的预测概率值与前一个值不相同
            # lazy累加策略被触发，求平均并计入结果，各个累积状态置为初始态
            auc += pos_count * pre_sum / count  # 注意这里只有正样本的部分才会被累积进结果
            count = 1
            pre_sum = i + 1                     # 累积rank被清空，更新为当前数rank
            last_pre = pred
            if label > 0:
                pos_count = 1                   # 如果当前样本是正样本 ，则置为1
            else:
                pos_count = 0                   # 反之置为0
        # 如果预测值是与前一个数相同的，进入累积状态
        else:
            pre_sum += i + 1                    # rank被逐渐累积
            count += 1                          # 计数器也被累计
            if label > 0:                       # 这里要另外记录正样本数，因为负样本在计算平均
                pos_count += 1                  # rank的时候会被计入，但不会被计入rank和的结果                  
    
    
    # 注意这里退出循环后我们要额外累加一下。
    # 这是因为我们上面lazy的累加策略，导致最后一组数据没有累加
    auc += pos_count * pre_sum / count         
    auc -= pos * (pos + 1) / 2                  # 减去正样本在正样本之前的情况即公式里的(m+1)m/2
    auc = auc / (pos * neg)                     # 除以总的组合数即公式里的m*n
    return auc