自定义auc函数+分布式计算方式分析

sklearn 中自带的auc函数

AUC 的计算方式如下：
$$AUC=\frac{{\sum }_i^{P\ast N}I(scor{e}_{pos}>scor{e}_{neg})}{P\ast N}$$

其中 P 表示正样本的数量，N表示负样本的数量。分母就是所有（正样本，负样本）对，每个样本对对应的分数是（$scor{e}_{pos}$, $scor{e}_{neg}$），则分子就是正样本分数大于负样本分数的样本对数量。AUC表示的就是在所有这样的样本对中，正样本分数大于负样本分数的占比。也就是模型能够准确预估用户是否点击的概率。

下面是自定义计算AUC的代码，在实际的系统中使用的时候一般都会通过分桶金近似计算的方式来达到在分布式系统中采用 map-reduce 的计算方式进行提速。

# 读入癌症数据集
from sklearn import datasets
from sklearn.model_selection import train_test_split

cancer=datasets.load_breast_cancer()
X=cancer.data
y=cancer.target

X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.4)

print('训练集维度:{}\n测试集维度:{}'.format(X_train.shape,X_test.shape))

from sklearn.linear_model import LogisticRegression
from sklearn import metrics

lr = LogisticRegression()                                        # 实例化一个LR模型
lr.fit(X_train,y_train)                                          # 训练模型
y_prob = lr.predict_proba(X_test)[:,1]                           # 预测1类的概率

# 直接计算auc
auc = metrics.roc_auc_score(y_test, y_prob)
print("auc={}".format(auc))

训练集维度:(341, 30)
测试集维度:(228, 30)
auc=0.9873357228195937

全量统计

import pandas as pd 
import numpy as np 

def get_auc(y_true, y_score):
    df = pd.DataFrame({"y_true": y_true, "y_score":y_score}).sort_values(by='y_score', ascending=False)
    # 正负样本数
    p_num = np.sum(y_true)
    n_num = len(y_true) - p_num 
    # 逆序对
    wrong_count = 0
    # 当前正样本的数量
    rest_p_count = p_num 
    # label 按照score排序后的结果
    sorted_labels = df.y_true
    for label in sorted_labels:
        if label == 1:
            rest_p_count -= 1
        else:
            wrong_count += rest_p_count
    my_auc = 1 - wrong_count / (p_num * n_num)
    print("p_num={}, n_num={}, auc={}".format(p_num, n_num, auc))
    return my_auc 

auc = get_auc(y_test, y_prob)
print(auc)

p_num=135, n_num=93, auc=0.9873357228195938

分桶统计

可通过map reduce方式实现并行计算，如果一个桶内正负样本数量分别为 p_num 和 n_num，则默认一半的pair为正序，一半为逆序。所以当分桶数量越多，则越准确。

# bucket 的数量，将score从 0～1.0 划分为 bucket_num 份，统计每个桶中的正负样本数，可map-reduce统计 
BUCKET_NUM = 100
# bucket_count.get(i) = [正样本数，负样本数]
bucket_count = dict()

# 下面统计每个桶中的正负样本数，分布式中可map-reduce并行统计
for i in range(len(y_test)):
    label = y_test[i]
    score = y_prob[i]
    # tmp_id 表示该样本落在的桶id
    tmp_id = int(score * BUCKET_NUM)
    if tmp_id not in bucket_count:
        bucket_count[tmp_id] = [0, 0]
    if label == 1:
        bucket_count.get(tmp_id)[0] += 1
    else:
        bucket_count.get(tmp_id)[1] += 1

# 统计 (p_score < n_score) 的数量
if len(bucket_count) * 100 < BUCKET_NUM:
    keyset = bucket_count.keys()
    keyset = sorted(keyset)
else:
    keyset = list(range(BUCKET_NUM))
    
sum_p_num = 0
sum_n_num = 0
sum_wrong_pair = 0 
for key in keyset:
    if key not in bucket_count:
        continue
    p_num = bucket_count.get(key)[0]
    n_num = bucket_count.get(key)[1]
    sum_wrong_pair += (sum_p_num * n_num + p_num * n_num / 2)
    sum_p_num += p_num
    sum_n_num += n_num
if sum_p_num == 0 or sum_n_num == 0:
    auc = 1.0
else:
    auc = 1 - sum_wrong_pair / (sum_p_num * sum_n_num)
print("p_num={}, n_num={}, auc={}".format(sum_p_num, sum_n_num, auc))

p_num=135, n_num=93, auc=0.9876941457586619

和前面计算的 0.9873357228195938 差异在万分位了，如果分桶数量增加的话会更加准确。