算法工程师常用python脚本，这原理你真的理解透了吗？

@ 欢迎关注作者公众号 算法全栈之路
@ filename calAuc.py

#!/usr/bin/python
import sys
import math

def calAUC(labels,probs):
 # 保证后面每个prob只计算一次面积一次
    i_sorted = sorted(xrange(len(probs)),key=lambda i: probs[i],reverse=True)

    auc_sum = 0.0 # 小梯形之和
    TP = 0.0 # 画auc图的时候 当前点的 tpr 取值
    TP_pre = 0.0 # 画auc图的时候 前一个点的 tpr 取值
    FP = 0.0 # 画auc图的时候 当前点的 fpr 取值
    FP_pre = 0.0 # 画auc图的时候 前一个点的 fpr 取值
    P = 0; # 正样本数目，纵轴的取值个数
    N = 0; # 负样本数目，横轴的取值个数

 # 赋初值，给与一个大于1.0, 不可能取到的值

    last_prob = probs[i_sorted[0]] + 1.0
    for i in xrange(len(probs)):
  # 循环各个小梯形，从原点往右往上
  # 小梯形呈现阶梯型，右边上变取值只比左边大一个单元长度
        if last_prob != probs[i_sorted[i]]:
   #（上底 + 下底）* 高  / 2
            auc_temp += (TP+TP_pre) * (FP-FP_pre) / 2.0
            TP_pre = TP # 向上
            FP_pre = FP # 向右
            last_prob = probs[i_sorted[i]] # 保证该prob只计算一次

  # 如果是正样本，向上走一步
        if labels[i_sorted[i]] == 1:
          TP = TP + 1
        else:
  # 负样本，向右走一步
          FP = FP + 1

 # 循环结束，计算最后一个小梯形
    auc_temp += (TP+TP_pre) * (FP-FP_pre) / 2.0
 # 注意，因为上面前进的都是单元长度，最终要除以多少个纵向长度，再除以多少个横向长度个数。把横轴和纵轴1的长度分别等分呢称多少份。纵轴为 1/TP，横轴为 1/FP.
 # 因为TP 和FP不相等，所以横轴和纵轴的单元长度不一样，决定着Auc图像的各不相同。
    auc = auc_temp / (TP * FP)
    return auc

def read_Auc_file():
    labels = []
    probs = []
    for line in sys.stdin:
        sp_line = line.split("\t")
        labels.append(int(sp_line[0]))
        if float(sp_line[1]) < 1e-8:
            probs.append(1e-8)
        else:
            probs.append(float(sp_line[1]))
    return labels,probs

if __name__ == "__main__":
 labels,probs = read_Auc_file()
 auc = calAUC(labels,probs)
 print "AUC:",auc

@ 欢迎关注作者公众号 算法全栈之路
@ filename calGAuc.py

#!/usr/bin/python
import sys
import math

def calGauc(group_list,score_list,label_list):
 # 保存全部数据的 dict
    all_data = {}
    all_auc = 0.0
 # 根据group分组属性，这里是imei把所有样本进行分组
 # 每个用户的样本作为各自的一组
    for i in range(len(group_list)):
        if group_list[i] in all_data:
            all_data[group_list[i]][0].append(score_list[i])
            all_data[group_list[i]][1].append(label_list[i])
        else:
            all_data[group_list[i]] = ([score_list[i]],[label_list[i]])

 #总共有多少样本
    all_size = 0
 # 对每个用户的样本分别计算Auc的值
    for imei,value in all_data.items():
        score = value[0]
        label = value[1]
        try:
            auc = calAUC(label,score)
   # 对每个用户分别计算的 Auc根据用户的样本多少击行加权求和。 
            all_size += len(score)
            all_auc += len(score) * auc
        except:
            pass

 #因为上面有得到的是加权求和的Auc,这里要除以总数，才能得到综合性的GAuc的值。
    return all_auc/all_size

def read_Gauc_file():
    labels = []
    probs = []
    groups = []
    for line in sys.stdin:
        sp_line = line.split()
        if(len(sp_line)!=3):
            continue;
        labels.append(int(sp_line[0]))
        if float(sp_line[1]) < 1e-8:
            probs.append(1e-8)
        else:
            probs.append(float(sp_line[1]))
        groups.append(sp_line[2])
 # 注意，这里和计算Auc不同，多了一列分组属性，这里是imei.
    return labels,probs,groups

if __name__ == "__main__":
    labels,probs,groups = read_Gauc_file()
    gauc = calGauc(groups,probs,labels)
 print "GAUC:",gauc

@ 欢迎关注作者公众号 算法全栈之路
@ filename sample.py

import sys,random

ns_sr = 1.0

if len(sys.argv) == 2:
    ns_sr = float(sys.argv[1])

for line in sys.stdin:
    try:
      ss = line.strip().split("\t")
      label = ss[0]
      value = ss[1]

   # 检查样本标签是否符合预期，不符合的拦截
      if "0" != label and "1" != label :
          continue

   # 只对负样本进行一定比例的采样操作,不符合的拦截
      if "1" != label and random.random() > ns_sr:
          continue

   # 未进行采样的样本，直接 pass
      print label + "\t" + value
    except Exception,e:
      continue

hadoop fs -text /user/app/samples/20210701/* |  python sample.py 0.2 > sampled_data.txt