计算ROC曲线

calc_roc.py

import scipy
import scipy.io as scio
import numpy as np
import cv2
import sklearn
from sklearn.decomposition import PCA
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
import matplotlib.pyplot as plt
import pickle as pkl
import matplotlib

def calc_roc(y_score, y_test, n_classes):
    """
    计算roc曲线
    :param y_score: 预测的置信度 形状为 m x n_classes 其中m为样本数 n_classes是类别数 每个元素代表第i个样本预测为第j类的置信度
    :param y_test: gt 形状为m x 1
    :param n_classes: 类别数
    :return: tpr, fpr
    """
    fpr = dict()
    tpr = dict()
    roc_auc = dict()
    y_test_bin = sklearn.preprocessing.label_binarize(y_test, classes=range(1, n_classes + 1))
    # 计算所有类别的tpr和fpr
    for class_id in range(n_classes):
        fpr[class_id], tpr[class_id], _ = metrics.roc_curve(y_test_bin[:, class_id], y_score[:, class_id])
        roc_auc[class_id] = metrics.auc(fpr[class_id], tpr[class_id])
    all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))
    mean_tpr = np.zeros_like(all_fpr)
    for i in range(n_classes):
        # 插值
        mean_tpr += scipy.interp(all_fpr, fpr[i], tpr[i])
    mean_tpr /= n_classes
    return (
        all_fpr, mean_tpr
    )

example.py

def face_recognize(pca_components, n_neighbor):
    """
    使用pca对人脸进行识别
    :param pca_components: 降维后保留的特征数目
    :param n_neighbor: 邻居阈值
    :return:
    """
    data = pkl.load(open('./data/PIE.pkl', 'rb'))
    dataset = np.array(data['fea'])
    labels = np.squeeze(np.array(data['gnd']))
    split = np.array(data['isTest'])
    print('数据集大小: ', dataset.shape)
    # 数据集划分
    test_idx = np.where(split == 1)[0]
    # 训练集是全集和测试集的差
    train_idx = list(set(range(len(dataset))) - set(test_idx))
    X_test, y_test = dataset[test_idx], labels[test_idx]
    X_train, y_train = dataset[train_idx], labels[train_idx]

    # 降维器
    decomposer = PCA(n_components=pca_components)
    # 这里无需减去平均脸, 因为sklearn的实现中已经减去了数据集的均值
    decomposer.fit(X_train)

    # 进行特征降维
    X_train_decompose = decomposer.transform(X_train)
    X_test_decompose = decomposer.transform(X_test)

    # 分类
    classifier = KNeighborsClassifier(n_neighbors=n_neighbor)
    classifier.fit(X_train_decompose, y_train)

    # 预测
    y_pred = classifier.predict(X_test_decompose)
    acc = metrics.accuracy_score(y_test, y_pred)
    print('ACC: {}%'.format(acc * 100))

    # 画roc曲线
    fpr, tpr = calc_roc(classifier.predict_proba(X_test_decompose), y_test, n_classes=len(set(y_test)))
    plt.plot(fpr, tpr)
    plt.xlabel('fpr')
    plt.ylabel('tpr')
    plt.tight_layout()
    plt.savefig('./outputs/roc_pca_baeline.png.png')
    plt.show()