ROC受试曲线AUC[TPR/ FPR/截断点/StratifiedKFold/KFold]

概念

ROC和AUC定义

ROC全称是“受试者工作特征”（Receiver Operating Characteristic）。ROC曲线的面积就是AUC（Area Under the Curve）。AUC用于衡量“二分类问题”机器学习算法性能（泛化能力）。

计算ROC需要知道的关键概念

首先，解释几个二分类问题中常用的概念：True Positive, False Positive, True Negative, False Negative。它们是根据真实类别与预测类别的组合来区分的。

假设有一批test样本，这些样本只有两种类别：正例和反例。机器学习算法预测类别如下图（左半部分预测类别为正例，右半部分预测类别为反例），而样本中真实的正例类别在上半部分，下半部分为真实的反例。

预测值为正例，记为P（Positive）
预测值为反例，记为N（Negative）
预测值与真实值相同，记为T（True）
预测值与真实值相反，记为F（False）

TP：预测类别是P（正例），真实类别也是P
FP：预测类别是P，真实类别是N（反例）
TN：预测类别是N，真实类别也是N
FN：预测类别是N，真实类别是P

样本中的真实正例类别总数即TP+FN。TPR即True Positive Rate，TPR = TP/(TP+FN)。同理，样本中的真实反例类别总数为FP+TN。FPR即False Positive Rate，FPR=FP/(TN+FP)。

还有一个概念叫”截断点”。机器学习算法对test样本进行预测后，可以输出各test样本对某个类别的相似度概率。比如t1是P类别的概率为0.3，一般我们认为概率低于0.5，t1就属于类别N。这里的0.5，就是”截断点”。总结一下，对于计算ROC，最重要的三个概念就是TPR, FPR, 截断点。

截断点取不同的值，TPR和FPR的计算结果也不同。将截断点不同取值下对应的TPR和FPR结果画于二维坐标系中得到的曲线，就是ROC曲线。横轴用FPR表示。

sklearn计算ROC

klearn给出了一个计算ROC的例子[1]

y = np.array([1, 1, 2, 2])
scores = np.array([0.1, 0.4, 0.35, 0.8])
fpr, tpr, thresholds = metrics.roc_curve(y, scores, pos_label=2)

通过计算，得到的结果（TPR, FPR, 截断点）为

fpr = array([ 0. ,  0.5,  0.5,  1. ])
tpr = array([ 0.5,  0.5,  1. ,  1. ])
thresholds = array([ 0.8 ,  0.4 ,  0.35,  0.1 ])#截断点

将结果中的FPR与TPR画到二维坐标中，得到的ROC曲线如下（蓝色线条表示），ROC曲线的面积用AUC表示（淡黄色阴影部分）。

将截断点依次取为score值将截断点依次取值为0.1,0.35,0.4,0.8时，计算TPR和FPR的结果，此处略：可参见https://blog.csdn.net/shenxiaoming77/article/details/72627882

心得

用下面描述表示TPR和FPR的计算过程，更容易记住 TPR：真实的正例中，被预测正确的比例 FPR：真实的反例中，被预测正确的比例最理想的分类器，就是对样本分类完全正确，即FP=0，FN=0。所以理想分类器TPR=1，FPR=0。

举栗子

'''例如，数据集一共有5个样本，真实类别为（1，0，0，1，0）；
二分类机器学习模型，得到的预测结果为（0.5，0.6，0.4，0.7，0.3）'''
import numpy as np
y_proba_ = np.array([0.5,0.6,0.4,0.7,0.3])# 阈值 >=0.5 类别1
y_ = np.array([1,1,0,1,0]) # ——> 对了4个，4/5= 0.8# 阈值 >=0.6 类别1
y_ = np.array([0,1,0,1,0]) # ——> 对了3个，3/5= 0.6# 阈值 >=0.4 类别
y_ = np.array([1,1,1,1,0])  # ——> 对了3个，3/5= 0.6

导包

import numpy as npimport matplotlib.pyplot as plt
%matplotlib inlinefrom sklearn.svm import SVCimport sklearn.datasets as datasets# 对数据进行分类
# StratifiedKFold 对数据进行分类，并且标准：按照正负样本的比例进行划分
from sklearn.model_selection import StratifiedKFold,KFold# 线性插值
from scipy import interp

线性插值的举例说明

x = np.linspace(0,2*np.pi,10)
y = np.sin(x)# 定义40个数据，#为横坐标连续数据
xinterp = np.linspace(0,2*np.pi,40)
''' yinterp ???'''# 线性插值
# 40个数据
'''interp(x, xp, fp, left=None, right=None, period=None)'''
yinterp = interp(xinterp,x,y)plt.scatter(x,y,color = 'red')
plt.plot(xinterp,yinterp,marker = 'o',color = 'green')

KFold/StratifiedKFold 举例说明

定义数据集

X1=np.array([[1,2,3,4],[11,12,13,14],[21,22,23,24],[31,32,33,34],[41,42,43,44],[51,52,53,54],[61,62,63,64],[71,72,73,74]
])# 正负样本比例1:1
y1=np.array([1,1,0,0,1,1,0,0])

random_state分解步骤说明

random_state = np.random.RandomState(seed = 12)
random_state.randint(0,100,size = 1)
Out：array([75])

KFold

'''KFold(n_splits=3, shuffle=False,
random_state=None[Used when ``shuffle`` == True.])'''
kFold = KFold(n_splits=4)for train,test in  kFold.split(X1,y1):print('行下标：',train,test)print("train--:",X1[train],y1[train])print("test--:",X1[test],y1[test])
Out:
行下标： [2 3 4 5 6 7] [0 1]
train--: [[21 22 23 24][31 32 33 34][41 42 43 44][51 52 53 54][61 62 63 64][71 72 73 74]] [0 0 1 1 0 0]
test--: [[ 1  2  3  4][11 12 13 14]] [1 1]
行下标： [0 1 4 5 6 7] [2 3]
train--: [[ 1  2  3  4][11 12 13 14][41 42 43 44][51 52 53 54][61 62 63 64][71 72 73 74]] [1 1 1 1 0 0]
test--: [[21 22 23 24][31 32 33 34]] [0 0]
行下标： [0 1 2 3 6 7] [4 5]
train--: [[ 1  2  3  4][11 12 13 14][21 22 23 24][31 32 33 34][61 62 63 64][71 72 73 74]] [1 1 0 0 0 0]
test--: [[41 42 43 44][51 52 53 54]] [1 1]
行下标： [0 1 2 3 4 5] [6 7]
train--: [[ 1  2  3  4][11 12 13 14][21 22 23 24][31 32 33 34][41 42 43 44][51 52 53 54]] [1 1 0 0 1 1]
test--: [[61 62 63 64][71 72 73 74]] [0 0]

StratifiedKFold

'''StratifiedKFold(n_splits=3, shuffle=False, random_state=None)'''
fold = StratifiedKFold(n_splits=4)for train,test in fold.split(X1,y1):print(train,test)
Out:
[1 3 4 5 6 7] [0 2]
[0 2 4 5 6 7] [1 3]
[0 1 2 3 5 7] [4 6]
[0 1 2 3 4 6] [5 7]

弋尾花举例说明

导包

# ROC曲线，AUC面积
from sklearn.metrics import roc_curve,auc

数据集

iris = datasets.load_iris()
X = iris['data']
y = iris['target']
display(X.shape,y.shape,y)
Out :
(150, 4)
(150,)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

将目标数据集缩减成二分类数据集

cond = y!=2
condX = X[cond]
y = y[cond]display(X.shape,y.shape)
Out:
(100, 4)
(100,)

添加800个属性

# 正态分布
np.random.randn(100,800).shape
Out：(100, 800)# X,y鸢尾花，4个属性，累加后一共804个属性
X = np.concatenate([X,np.random.randn(100,800)],axis = 1)
X.shape
Out：(100, 804)

声明SVC算法 新建auc，tprs空列表，定义0-1连续100个横坐标插值

# 声明算法
'''SVC(C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0,
shrinking=True, probability=False, tol=0.001, cache_size=200,
class_weight=None, verbose=False, max_iter=-1, decision_function_shape='ovr',
random_state=None)'''
svc_linear = SVC(kernel='linear',probability=True)skFold = StratifiedKFold(n_splits=6)# 用来存储每一份数据集根据area = auc(fpr,trp)求出的auc面积
# aucs.append(area)，求标准方差：auc_std = np.std(aucs)
aucs = []# ROC曲线横纵坐标分别是：fpr，tpr
fpr_mean = np.linspace(0,1,100)# 用来存储每一份数据集根据tpr_m = interp(fpr_mean,fpr,trp)计算出tpr_m
# tprs.append(tpr_m)，求tpr的平均值：tpr_mean = np.mean(tprs,axis = 0)
tprs = []

使用ROC曲线,AUC面积评估二分类模型

k = 0
for train,test in skFold.split(X,y):
#     print(train.shape,test.shape)# 使用循环分割成6份训练集做训练fitsvc_linear.fit(X[train],y[train])# 使用训练后的算法 预测分割后的测试集提取概率proba_y_ = svc_linear.predict_proba(X[test])''' roc_curve(y_true, y_score, pos_label=None, sample_weight=None,drop_intermediate=True)'''# 使用roc_curve，放入参数：正确目标分类y[test]，测试概率，即截断点，求出fpr,trpfpr,trp,thresholds = roc_curve(y[test],proba_y_[:,1])'''auc(x, y, reorder=False)'''# 使用fpr,trp求面积 areaarea = auc(fpr,trp)# 将每一次的训练得到的面积加入aucs列表，一次就有6个面积的累加,求方差使用aucs.append(area)# 使用0-1的横坐标插值fpr_mean，求插值y:tpr_mtpr_m = interp(fpr_mean,fpr,trp)# 将每次的插值放入tprs列表，一次就有6个tpr_m list，求平均纵坐标使用tprs.append(tpr_m)plt.plot(fpr,trp,label = 'Fold:%d AUC:%0.4f'%(k,area),alpha = 0.4,ls = '--')k+=1print('aucs--',len(aucs)) # 66[这个数字会变化]
print('tprs--',np.array(tprs).shape) # (66[这个数字会变化], 100)
tpr_mean = np.mean(tprs,axis = 0)   tpr_mean[0] = 0auc_mean = auc(fpr_mean,tpr_mean)# 标准方差
auc_std = np.std(aucs)plt.plot(fpr_mean,tpr_mean,label='Fold_Mean AUC:%0.4f$\pm$%0.2f'%(auc_mean,auc_std),color = 'green')
# 显示标签
plt.legend()

声明逻辑斯蒂回归算法 新建auc，tprs空列表，定义0-1连续100个横坐标插值

# 声明算法
from sklearn.linear_model import LogisticRegression
logistic = LogisticRegression()skFold = StratifiedKFold(n_splits=6)aucs = []# ROC曲线横纵坐标分别是：fpr，tprfpr_mean = np.linspace(0,1,100)tprs = []

使用ROC曲线,AUC面积评估二分类模型

k = 0
for train,test in skFold.split(X,y):logistic.fit(X[train],y[train])proba_y_ = logistic.predict_proba(X[test])fpr,trp,thresholds = roc_curve(y[test],proba_y_[:,1])
#     print('thresholds',thresholds)area = auc(fpr,trp)aucs.append(area)tpr_m = interp(fpr_mean,fpr,trp)tprs.append(tpr_m)plt.plot(fpr,trp,label = 'Fold:%d AUC:%0.4f'%(k,area),alpha = 0.4,ls = '--')k+=1  tpr_mean = np.mean(tprs,axis = 0)   tpr_mean[0] = 0auc_mean = auc(fpr_mean,tpr_mean)# 标准方差
auc_std = np.std(aucs)plt.plot(fpr_mean,tpr_mean,label='Fold_Mean AUC:%0.4f$\pm$%0.2f'%(auc_mean,auc_std),color = 'green')plt.legend()