python  画 ROC 曲线的实现代码

import numpy as np
import matplotlib.pyplot as plt

from sklearn.metrics import auc  ###计算roc和auc
import pandas as pd

base = "D:\\WFLW\\wflw_blur_128\\ROC\\"

df =pd.read_csv( base + "sobel_roc.txt", encoding='utf8', delimiter=' ', header=0)
df_lap =pd.read_csv( base + "lap_roc.txt", encoding='utf8', delimiter=' ', header=0)
df_dft =pd.read_csv( base + "dft_roc.txt", encoding='utf8', delimiter=' ', header=0)
df_cnn =pd.read_csv( base + "cnn_roc.txt", encoding='utf8', delimiter=' ', header=0)

tpr = df['tpr']
fpr = df['fpr']

tpr_lap = df_lap['tpr']
fpr_lap = df_lap['fpr']

tpr_dft = df_dft['tpr']
fpr_dft = df_dft['fpr']

tpr_cnn = df_cnn['tpr']
fpr_cnn = df_cnn['fpr']

roc_auc = auc(fpr, tpr) ###计算auc的值

roc_auc_lap = auc(fpr_lap, tpr_lap) ###计算auc的值

roc_auc_dft = auc(fpr_dft, tpr_dft) ###计算auc的值

roc_auc_cnn = auc(fpr_cnn, tpr_cnn)

print(roc_auc)

plt.figure()
lw = 2
plt.figure(figsize=(10,10))
plt.plot(fpr, tpr, color='darkorange', lw=lw, label='Sobel ROC curve (area = %0.2f)' % roc_auc) ###假正率为横坐标，真正率为纵坐标做曲线

plt.plot(fpr_lap, tpr_lap, color='navy', lw=lw, label='Lap ROC curve (area = %0.2f)' % roc_auc_lap)

plt.plot(fpr_dft, tpr_dft, color='red', lw=lw, label='Dft ROC curve (area = %0.2f)' % roc_auc_dft)

plt.plot(fpr_cnn, tpr_cnn, color='green', lw=lw, label='CNN ROC curve (area = %0.2f)' % roc_auc_cnn)
#plt.plot(tpr, fpr, 'k--', label='Mean ROC (area = %0.2f)' % 1, lw=2)

#plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')

plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.savefig(base + "roc_img\\sobel_roc.jpg")
plt.show()

画图结果

text 的内容格式：

问题需求：

二分类问题评估指标有ROC曲线--------->对sklearn.metrics.roc_curve中的评估指标计算方式有疑问

样例代码：

>>> import numpy as np
>>> from sklearn import metrics
>>> 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)
>>> 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])

参数解释：

y：真实的样本标签，默认为{0，1}或者{-1，1}。如果要设置为其它值，则 pos_label 参数要设置为特定值。例如要令样本标签为{1，2}，其中2表示正样本，则pos_label=2

y_score：对每个样本的预测结果

pos_label：正样本的标签

FPR：False positive rate

TPR：True positive rate

thresholds：阈值的选取规则是在scores值中从大到小的以此选取

计算原理：

ROC曲线图生成：

# -*- coding: utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.metrics import roc_curve, auc  ###计算roc和auc
from sklearn.model_selection import train_test_split

# Import some data to play with
iris = datasets.load_iris()
X = iris.data
y = iris.target

##变为2分类
X, y = X[y != 2], y[y != 2]

# Add noisy features to make the problem harder
random_state = np.random.RandomState(0)
n_samples, n_features = X.shape
X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]

# shuffle and split training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.3, random_state=0)

# Learn to predict each class against the other
svm = svm.SVC(kernel='linear', probability=True,random_state=random_state)

###通过decision_function()计算得到的y_score的值，用在roc_curve()函数中
y_score = svm.fit(X_train, y_train).decision_function(X_test)

# Compute ROC curve and ROC area for each class
fpr,tpr,threshold = roc_curve(y_test, y_score) ###计算真正率和假正率
roc_auc = auc(fpr,tpr) ###计算auc的值

plt.figure()
lw = 2
plt.figure(figsize=(10,10))
plt.plot(fpr, tpr, color='darkorange',
         lw=lw, label='ROC curve (area = %0.2f)' % roc_auc) ###假正率为横坐标，真正率为纵坐标做曲线
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

参考链接：

https://blog.csdn.net/w1301100424/article/details/84546194
https://blog.csdn.net/u014264373/article/details/80487766
https://blog.csdn.net/mago2015/article/details/82833793

这个直接画：

from sklearn import metrics
import numpy as np
import matplotlib.pyplot as plt

plt.figure(0).clf()  # plt.close()将完全关闭图形窗口，其中plt.clf()将清除图形-您仍然可以在其上绘制另一个绘图。

label = np.random.randint(2, size=1000)

pred=[ random.random()/1.5 if data==0 else random.random() for data in label]
fpr, tpr, thresh = metrics.roc_curve(label, np.array(pred))

auc = metrics.roc_auc_score(label, pred)
plt.plot(fpr, tpr, label="data 1, auc=" + str(auc))

label = np.random.randint(2, size=1000)

pred=[ random.uniform(0, 0.7) if data==0 else random.uniform(0.4, 1) for data in label]
fpr, tpr, thresh = metrics.roc_curve(label, pred)
auc = metrics.roc_auc_score(label, pred)
plt.plot(fpr, tpr, label="data 2, auc=" + str(auc))

plt.legend(loc=0)  # 说明所在位置
plt.show()

这个读文件：

label.txt:

1
0
1
0
1
0

feature.txt

0.1
0.2
0.2
0.2
0.2
0.3

代码：

# -*- coding: utf-8 -*-

import math

import sklearn

import numpy as np

import matplotlib.pyplot as plt

import skimage
import sklearn.metrics.pairwise as pw

#读取标签文件

def read_labels(labelfile):

    fin=open(labelfile)

    lines=fin.readlines()

    labels=np.empty((len(lines),))

    k=0;

    for line in lines:

        labels[k]=int(line)

        k=k+1;

    fin.close()

    return labels

def read_Feautures(labelfile):

    fin=open(labelfile)

    lines=fin.readlines()

    labels=np.empty((len(lines),))

    k=0;

    for line in lines:

        labels[k]=float(line)

        k=k+1;

    fin.close()

    return labels

#画ROC曲线图

def draw_roc_curve(fpr1,tpr1,fpr2,tpr2, title='cosine',save_name='roc_lfw'):

    plt.figure()

    plt.plot(fpr1, tpr1,'r')

    plt.plot(fpr2, tpr2,'g')

    plt.plot([0, 1], [0, 1], 'k--')

    plt.xlim([0.0, 1.0])

    plt.ylim([0.0, 1.0])

    plt.xlabel('FPR')

    plt.ylabel('TPR')

    plt.title('ROC(Receiver operating characteristic)using: '+title)

    plt.legend(loc="lower right")

    plt.show()

    plt.savefig(save_name+'.png')

if __name__=='__main__':

    labels = read_labels(u"label.txt")

    predicts = read_Feautures(u"feature.txt")

    fpr1, tpr1, threshold1s=sklearn.metrics.roc_curve(labels,predicts)

    print(threshold1s)

    #draw_roc_curve(fpr1,tpr1,title='JSS',save_name='lfw_evaluate')

    labels = read_labels(u"label.txt")

    predicts = read_Feautures(u"feature.txt")

    fpr2, tpr2, threshold2s=sklearn.metrics.roc_curve(labels,predicts)

    print(threshold2s)

    draw_roc_curve(fpr1,tpr1,fpr2,tpr2,title='AS',save_name='lfw_evaluate')

以下内容转自：

https://blog.csdn.net/qq_38410428/article/details/88106395

基本概念
precision：预测为对的当中，原本为对的比例（越大越好，1为理想状态）
recall：原本为对的当中，预测为对的比例（越大越好，1为理想状态）
F-measure：F度量是对准确率和召回率做一个权衡（越大越好，1为理想状态，此时precision为1，recall为1）
accuracy：预测对的（包括原本是对预测为对，原本是错的预测为错两种情形）占整个的比例（越大越好，1为理想状态）
fp rate：原本是错的预测为对的比例（越小越好，0为理想状态）
tp rate：原本是对的预测为对的比例（越大越好，1为理想状态）
ROC曲线通常在Y轴上具有真阳性率，在X轴上具有假阳性率。这意味着图的左上角是“理想”点 - 误报率为零，真正的正率为1。这不太现实，但它确实意味着曲线下面积（AUC）通常更好。二分类问题：ROC曲线

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import time
start_time = time.time()
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import recall_score,accuracy_score
from sklearn.metrics import precision_score,f1_score
from keras.optimizers import Adam,SGD,sgd
from keras.models import load_model

print('读取数据')
X_train = np.load('x_train-rotate_2.npy')
Y_train = np.load('y_train-rotate_2.npy')
print(X_train.shape)
print(Y_train.shape)


print('获取测试数据和验证数据')
X_train, X_valid, Y_train, Y_valid = train_test_split(X_train, Y_train, test_size=0.1, random_state=666)

Y_train = np.asarray(Y_train,np.uint8)
Y_valid = np.asarray(Y_valid,np.uint8)
X_valid = np.array(X_valid, np.float32) / 255.


print('获取模型')
model = load_model('./model/InceptionV3_model.h5')
opt = Adam(lr=1e-4)
model.compile(optimizer=opt, loss='binary_crossentropy')


print("Predicting")
Y_pred = model.predict(X_valid)
Y_pred = [np.argmax(y) for y in Y_pred]  # 取出y中元素最大值所对应的索引
Y_valid = [np.argmax(y) for y in Y_valid]

# micro：多分类　　
# weighted：不均衡数量的类来说，计算二分类metrics的平均
# macro：计算二分类metrics的均值，为每个类给出相同权重的分值。
precision = precision_score(Y_valid, Y_pred, average='weighted')
recall = recall_score(Y_valid, Y_pred, average='weighted')
f1_score = f1_score(Y_valid, Y_pred, average='weighted')
accuracy_score = accuracy_score(Y_valid, Y_pred)
print("Precision_score:",precision)
print("Recall_score:",recall)
print("F1_score:",f1_score)
print("Accuracy_score:",accuracy_score)

# 二分类　ＲＯＣ曲线
# roc_curve:真正率（True Positive Rate , TPR）或灵敏度（sensitivity）
# 横坐标：假正率（False Positive Rate , FPR）
fpr, tpr, thresholds_keras = roc_curve(Y_valid, Y_pred)
auc = auc(fpr, tpr)
print("AUC : ", auc)
plt.figure()
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr, label='Keras (area = {:.3f})'.format(auc))
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.title('ROC curve')
plt.legend(loc='best')
plt.savefig("../images/ROC/ROC_2分类.png")
plt.show()


print("--- %s seconds ---" % (time.time() - start_time))

ROC图如下所示：

多分类问题：ROC曲线
ROC曲线通常用于二分类以研究分类器的输出。为了将ROC曲线和ROC区域扩展到多类或多标签分类，有必要对输出进行二值化。⑴可以每个标签绘制一条ROC曲线。⑵也可以通过将标签指示符矩阵的每个元素视为二元预测（微平均）来绘制ROC曲线。⑶另一种用于多类别分类的评估方法是宏观平均，它对每个标签的分类给予相同的权重。

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import time
start_time = time.time()
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import recall_score,accuracy_score
from sklearn.metrics import precision_score,f1_score
from keras.optimizers import Adam,SGD,sgd
from keras.models import load_model
from itertools import cycle
from scipy import interp
from sklearn.preprocessing import label_binarize

nb_classes = 5
print('读取数据')
X_train = np.load('x_train-resized_5.npy')
Y_train = np.load('y_train-resized_5.npy')
print(X_train.shape)
print(Y_train.shape)


print('获取测试数据和验证数据')
X_train, X_valid, Y_train, Y_valid = train_test_split(X_train, Y_train, test_size=0.1, random_state=666)

Y_train = np.asarray(Y_train,np.uint8)
Y_valid = np.asarray(Y_valid,np.uint8)
X_valid = np.asarray(X_valid, np.float32) / 255.


print('获取模型')
model = load_model('./model/SE-InceptionV3_model.h5')
opt = Adam(lr=1e-4)
model.compile(optimizer=opt, loss='categorical_crossentropy')


print("Predicting")
Y_pred = model.predict(X_valid)
Y_pred = [np.argmax(y) for y in Y_pred]  # 取出y中元素最大值所对应的索引
Y_valid = [np.argmax(y) for y in Y_valid]

# Binarize the output
Y_valid = label_binarize(Y_valid, classes=[i for i in range(nb_classes)])
Y_pred = label_binarize(Y_pred, classes=[i for i in range(nb_classes)])


# micro：多分类　　
# weighted：不均衡数量的类来说，计算二分类metrics的平均
# macro：计算二分类metrics的均值，为每个类给出相同权重的分值。
precision = precision_score(Y_valid, Y_pred, average='micro')
recall = recall_score(Y_valid, Y_pred, average='micro')
f1_score = f1_score(Y_valid, Y_pred, average='micro')
accuracy_score = accuracy_score(Y_valid, Y_pred)
print("Precision_score:",precision)
print("Recall_score:",recall)
print("F1_score:",f1_score)
print("Accuracy_score:",accuracy_score)


# roc_curve:真正率（True Positive Rate , TPR）或灵敏度（sensitivity）
# 横坐标：假正率（False Positive Rate , FPR）


# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(nb_classes):
    fpr[i], tpr[i], _ = roc_curve(Y_valid[:, i], Y_pred[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])

# Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(Y_valid.ravel(), Y_pred.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])


# Compute macro-average ROC curve and ROC area

# First aggregate all false positive rates
all_fpr = np.unique(np.concatenate([fpr[i] for i in range(nb_classes)]))

# Then interpolate all ROC curves at this points
mean_tpr = np.zeros_like(all_fpr)
for i in range(nb_classes):
    mean_tpr += interp(all_fpr, fpr[i], tpr[i])

# Finally average it and compute AUC
mean_tpr /= nb_classes

fpr["macro"] = all_fpr
tpr["macro"] = mean_tpr
roc_auc["macro"] = auc(fpr["macro"], tpr["macro"])

# Plot all ROC curves
lw = 2
plt.figure()
plt.plot(fpr["micro"], tpr["micro"],
         label='micro-average ROC curve (area = {0:0.2f})'
               ''.format(roc_auc["micro"]),
         color='deeppink', linestyle=':', linewidth=4)

plt.plot(fpr["macro"], tpr["macro"],
         label='macro-average ROC curve (area = {0:0.2f})'
               ''.format(roc_auc["macro"]),
         color='navy', linestyle=':', linewidth=4)

colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(nb_classes), colors):
    plt.plot(fpr[i], tpr[i], color=color, lw=lw,
             label='ROC curve of class {0} (area = {1:0.2f})'
             ''.format(i, roc_auc[i]))

plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Some extension of Receiver operating characteristic to multi-class')
plt.legend(loc="lower right")
plt.savefig("../images/ROC/ROC_5分类.png")
plt.show()


print("--- %s seconds ---" % (time.time() - start_time))

ROC图如下所示：