189 8069 5689
tensorflow添加自定义的auc计算operator
创新互联主营夏河网站建设的网络公司,主营网站建设方案,成都app软件开发公司,夏河h5重庆小程序开发搭建,夏河网站营销推广欢迎夏河等地区企业咨询
tensorflow可以很方便的添加用户自定义的operator(如果不添加也可以采用sklearn的auc计算函数或者自己写一个 但是会在python执行，这里希望在graph中也就是c++端执行这个计算)
这里根据工作需要添加一个计算auc的operator，只给出最简单实现，后续高级功能还是参考官方wiki
注意tensorflow现在和最初的官方wiki有变化，原wiki貌似是需要重新bazel编译整个tensorflow，然后使用比如tf.user_op.auc这样。
目前wiki给出的方式=0.6.0版本，采用plug-in的方式，更加灵活可以直接用g++编译一个so载入，解耦合，省去了编译tensorflow过程，即插即用。
首先auc的operator计算的文件
tensorflow/core/user_ops/auc.cc
/* Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// An auc Op.
#include "tensorflow/core/framework/op.h"
#include "tensorflow/core/framework/op_kernel.h"
using namespace tensorflow;
using std::vector;
//@TODO add weight as optional input
REGISTER_OP("Auc")
.Input("predicts: T1")
.Input("labels: T2")
.Output("z: float")
.Attr("T1: {float, double}")
.Attr("T2: {float, double}")
//.Attr("T1: {float, double}")
//.Attr("T2: {int32, int64}")
.SetIsCommutative()
.Doc(R"doc(
Given preidicts and labels output it's auc
)doc");
class AucOp : public OpKernel {
public:
explicit AucOp(OpKernelConstruction* context) : OpKernel(context) {}
templatetypename ValueVec
void index_sort(const ValueVec valueVec, vectorint indexVec)
{
indexVec.resize(valueVec.size());
for (size_t i = 0; i indexVec.size(); i++)
{
indexVec[i] = i;
}
std::sort(indexVec.begin(), indexVec.end(),
[valueVec](const int l, const int r) { return valueVec(l) valueVec(r); });
}
void Compute(OpKernelContext* context) override {
// Grab the input tensor
const Tensor predicts_tensor = context-input(0);
const Tensor labels_tensor = context-input(1);
auto predicts = predicts_tensor.flatfloat(); //输入能接受float double那么这里如何都处理?
auto labels = labels_tensor.flatfloat();
vectorint indexes;
index_sort(predicts, indexes);
typedef float Float;
Float oldFalsePos = 0;
Float oldTruePos = 0;
Float falsePos = 0;
Float truePos = 0;
Float oldOut = std::numeric_limitsFloat::infinity();
Float result = 0;
for (size_t i = 0; i indexes.size(); i++)
{
int index = indexes[i];
Float label = labels(index);
Float prediction = predicts(index);
Float weight = 1.0;
//Pval3(label, output, weight);
if (prediction != oldOut) //存在相同值得情况是特殊处理的
{
result += 0.5 * (oldTruePos + truePos) * (falsePos - oldFalsePos);
oldOut = prediction;
oldFalsePos = falsePos;
oldTruePos = truePos;
}
if (label 0)
truePos += weight;
else
falsePos += weight;
}
result += 0.5 * (oldTruePos + truePos) * (falsePos - oldFalsePos);
Float AUC = result / (truePos * falsePos);
// Create an output tensor
Tensor* output_tensor = NULL;
TensorShape output_shape;
OP_REQUIRES_OK(context, context-allocate_output(0, output_shape, output_tensor));
output_tensor-scalarfloat()() = AUC;
}
};
REGISTER_KERNEL_BUILDER(Name("Auc").Device(DEVICE_CPU), AucOp);
编译：
$cat gen-so.sh
TF_INC=$(python -c 'import tensorflow as tf; print(tf.sysconfig.get_include())')
TF_LIB=$(python -c 'import tensorflow as tf; print(tf.sysconfig.get_lib())')
i=$1
o=${i/.cc/.so}
g++ -std=c++11 -shared $i -o $o -I $TF_INC -l tensorflow_framework -L $TF_LIB -fPIC -Wl,-rpath $TF_LIB
$sh gen-so.sh auc.cc
会生成auc.so
使用的时候
auc_module = tf.load_op_library('auc.so')
#auc = tf.user_ops.auc #0.6.0之前的tensorflow 自定义op方式
auc = auc_module.auc
evaluate_op = auc(py_x, Y) #py_x is predicts, Y is labels
使用sklearn的一系列方法后可以很方便的绘制处ROC曲线，这里简单实现以下。
主要是利用混淆矩阵中的知识作为绘制的数据（如果不是很懂可以先看看这里的基础）：
tpr(Ture Positive Rate)：真阳率 图像的纵坐标
fpr(False Positive Rate)：阳率（伪阳率） 图像的横坐标
mean_tpr：累计真阳率求平均值
mean_fpr：累计阳率求平均值
import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import StratifiedKFold
iris = datasets.load_iris()
X = iris.data
y = iris.target
X, y = X[y != 2], y[y != 2] # 去掉了label为2，label只能二分，才可以。
n_samples, n_features = X.shape
# 增加噪声特征
random_state = np.random.RandomState(0)
X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]
cv = StratifiedKFold(n_splits=6) #导入该模型，后面将数据划分6份
classifier = svm.SVC(kernel='linear', probability=True,random_state=random_state) # SVC模型 可以换作AdaBoost模型试试
# 画平均ROC曲线的两个参数
mean_tpr = 0.0 # 用来记录画平均ROC曲线的信息
mean_fpr = np.linspace(0, 1, 100)
cnt = 0
for i, (train, test) in enumerate(cv.split(X,y)): #利用模型划分数据集和目标变量 为一一对应的下标
cnt +=1
probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test]) # 训练模型后预测每条样本得到两种结果的概率
fpr, tpr, thresholds = roc_curve(y[test], probas_[:, 1]) # 该函数得到伪正例、真正例、阈值，这里只使用前两个
mean_tpr += np.interp(mean_fpr, fpr, tpr) # 插值函数 interp(x坐标,每次x增加距离,y坐标) 累计每次循环的总值后面求平均值
mean_tpr[0] = 0.0 # 将第一个真正例=0 以0为起点
roc_auc = auc(fpr, tpr) # 求auc面积
plt.plot(fpr, tpr, lw=1, label='ROC fold {0:.2f} (area = {1:.2f})'.format(i, roc_auc)) # 画出当前分割数据的ROC曲线
plt.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Luck') # 画对角线
mean_tpr /= cnt # 求数组的平均值
mean_tpr[-1] = 1.0 # 坐标最后一个点为（1,1） 以1为终点
mean_auc = auc(mean_fpr, mean_tpr)
plt.plot(mean_fpr, mean_tpr, 'k--',label='Mean ROC (area = {0:.2f})'.format(mean_auc), lw=2)
plt.xlim([-0.05, 1.05]) # 设置x、y轴的上下限，设置宽一点，以免和边缘重合，可以更好的观察图像的整体
plt.ylim([-0.05, 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()
1. 引入相关包
使用matplotlib包作为绘图库，故要引入相关的包，如下所示。
import matplotlib.pyplot as plt
2. 数据处理部分
首先引入numpy包对数据进行处理，如下所示。
import numpy as np
要计算AUC和AUPR，还应该引入sklearn中计算相关值的包，如下所示。
from sklearn.metrics import roc_curve, auc
from sklearn.metrics import precision_recall_curve
然后导入相关数据
y_1 = np.load('product_HSIC,y.npy')
yp_1 = np.load('product_HSIC,yp.npy')
y_2 = np.load('product_mean,y.npy')
yp_2 = np.load('product_mean,yp.npy')
y_3 = np.load('sum_HSIC,y.npy')
yp_3 = np.load('sum_HSIC,yp.npy')
y_4 = np.load('sum_mean,y.npy')
yp_4 = np.load('sum_mean,yp.npy')
2.1 计算AUC值
AUC，即AUROC，指的是由TPR和FPR围成的ROC曲线下的面积。
将分类任务的实际值和预测值作为参数输入给roc_curve()方法可以得到FPR、TPR和对应的阈值。
auc()方法可以计算曲线下的面积，将FPR和TPR作为参数输入，即可获得AUC值。
fpr_1, tpr_1, threshold_1 = roc_curve(y_1, yp_1) # 计算FPR和TPR
auc_1 = auc(fpr_1, tpr_1) # 计算AUC值
fpr_2, tpr_2, threshold_2 = roc_curve(y_2, yp_2)
auc_2 = auc(fpr_2, tpr_2)
fpr_3, tpr_3, threshold_3 = roc_curve(y_3, yp_3)
auc_3 = auc(fpr_3, tpr_3)
fpr_4, tpr_4, threshold_4 = roc_curve(y_4, yp_4)
auc_4 = auc(fpr_4, tpr_4)
2.2 计算AUPR值
AUPR，指的是由Precision和Recall围成的PR曲线下的面积。
将分类任务的实际值和预测值作为参数输入给precision_recall_curve()方法可以得到Precision、Recall和对应的阈值。
auc()方法可以计算曲线下的面积，将Recall和Precision（注意顺序）作为参数输入，即可获得AUPR值。
损失函数：衡量模型输出与真实标签之间的差异。与损失函数有关的还有代价函数和目标函数。
损失函数（Loss Function）：计算一个样本的差异， L o s s = f ( y ^ , y ) Loss=f\left ( \hat{y},y \right ) Loss=f(
y
^
,y)
代价函数（Cost Function）：计算整个训练集loss的一个平均值， c o s t = 1 N ∑ i N f ( y ^ , y ) cos t= \frac{1}{N}\sum_{i}^{N}f\left ( \hat{y},y \right ) cost=
N
1
∑
i
N
f(
y
^
,y)
目标函数（Objective Function）：衡量模型的整体拟合程度，过拟合和欠拟合，obj = cost + Regularization
所以在衡量模型的输出和真实标签之间的差异时的损失函数其实是指代价函数，下面看一下pytorch中的损失函数：
利用Python画ROC曲线，以及AUC值的计算\
前言
ROC（Receiver Operating Characteristic）曲线和AUC常被用来评价一个二值分类器（binary classifier）的优劣。这篇文章将先简单的介绍ROC和AUC，而后用实例演示如何python作出ROC曲线图以及计算AUC。
AUC介绍
AUC(Area Under Curve)是机器学习二分类模型中非常常用的评估指标，相比于F1-Score对项目的不平衡有更大的容忍性，目前常见的机器学习库中(比如scikit-learn)一般也都是集成该指标的计算，但是有时候模型是单独的或者自己编写的，此时想要评估训练模型的好坏就得自己搞一个AUC计算模块，本文在查询资料时发现libsvm-tools有一个非常通俗易懂的auc计算，因此抠出来用作日后之用。
AUC计算
AUC的计算分为下面三个步骤：
1、计算数据的准备，如果模型训练时只有训练集的话一般使用交叉验证的方式来计算，如果有评估集(evaluate)一般就可以直接计算了，数据的格式一般就是需要预测得分以及其目标类别（注意是目标类别，不是预测得到的类别）
2、根据阈值划分得到横（X:False Positive Rate）以及纵（Y:True Positive Rate）点
3、将坐标点连成曲线之后计算其曲线下面积,就是AUC的值
直接上python代码
#! -*- coding=utf-8 -*-
import pylab as pl
from math import log,exp,sqrt
evaluate_result="you file path"
db = [] #[score,nonclk,clk]
pos, neg = 0, 0
with open(evaluate_result,'r') as fs:
for line in fs:
nonclk,clk,score = line.strip().split('\t')
nonclk = int(nonclk)
clk = int(clk)
score = float(score)
db.append([score,nonclk,clk])
pos += clk
neg += nonclk
db = sorted(db, key=lambda x:x[0], reverse=True)
#计算ROC坐标点
xy_arr = []
tp, fp = 0., 0.
for i in range(len(db)):
tp += db[i][2]
fp += db[i][1]
xy_arr.append([fp/neg,tp/pos])
#计算曲线下面积
auc = 0.
prev_x = 0
for x,y in xy_arr:
if x != prev_x:
auc += (x - prev_x) * y
prev_x = x
print "the auc is %s."%auc
x = [_v[0] for _v in xy_arr]
y = [_v[1] for _v in xy_arr]
pl.title("ROC curve of %s (AUC = %.4f)" % ('svm',auc))
pl.xlabel("False Positive Rate")
pl.ylabel("True Positive Rate")
pl.plot(x, y)# use pylab to plot x and y
pl.show()# show the plot on the screen
输入的数据集可以参考svm预测结果
其格式为:
nonclk \t clk \t score
其中：
1、nonclick:未点击的数据，可以看做负样本的数量
2、clk:点击的数量，可以看做正样本的数量
3、score:预测的分数，以该分数为group进行正负样本的预统计可以减少AUC的计算量
运行的结果为:
如果本机没安装pylab可以直接注释依赖以及画图部分
注意
上面贴的代码:
1、只能计算二分类的结果（至于二分类的标签随便处理）
2、上面代码中每个score都做了一次阈值，其实这样效率是相当低的，可以对样本进行采样或者在计算横轴坐标时进行等分计算