AUC/ROC：面试中80%都会问的知识点

"""ROC"""
import numpy as np
from mindspore._checkparam import Validator as validator
from .metric import Metric
class ROC(Metric):
  
 def __init__(self, class_num=None, pos_label=None):
 super().__init__()
 # 分类数为一个整数
 self.class_num = class_num if class_num is None else validator.check_value_type("class_num", class_num, [int])
 # 确定正类的整数，对于二分类问题，它被转换为1。对于多分类问题，不应设置此参数，因为它在[0，num_classes-1]范围内迭代更改。
 self.pos_label = pos_label if pos_label is None else validator.check_value_type("pos_label", pos_label, [int])
 self.clear()
 def clear(self):
 """清除历史数据"""
 self.y_pred = 0
 self.y = 0
 self.sample_weights = None
 self._is_update = False
 def _precision_recall_curve_update(self, y_pred, y, class_num, pos_label):
 """更新曲线"""
 if not (len(y_pred.shape) == len(y.shape) or len(y_pred.shape) == len(y.shape) + 1):
 raise ValueError("y_pred and y must have the same number of dimensions, or one additional dimension for"
 " y_pred.")
 # 二分类验证
 if len(y_pred.shape) == len(y.shape):
 if class_num is not None and class_num != 1:
 raise ValueError('y_pred and y should have the same shape, but number of classes is different from 1.')
 class_num = 1
 if pos_label is None:
 pos_label = 1
 y_pred = y_pred.flatten()
 y = y.flatten()
 # 多分类验证
 elif len(y_pred.shape) == len(y.shape) + 1:
 if pos_label is not None:
 raise ValueError('Argument `pos_label` should be `None` when running multiclass precision recall '
 'curve, but got {}.'.format(pos_label))
 if class_num != y_pred.shape[1]:
 raise ValueError('Argument `class_num` was set to {}, but detected {} number of classes from '
 'predictions.'.format(class_num, y_pred.shape[1]))
 y_pred = y_pred.transpose(0, 1).reshape(class_num, -1).transpose(0, 1)
 y = y.flatten()
 return y_pred, y, class_num, pos_label
 def update(self, *inputs):
 """
 更新预测值和真实值。
 """
 # 输入数量的校验
 if len(inputs) != 2:
 raise ValueError('ROC need 2 inputs (y_pred, y), but got {}'.format(len(inputs)))
 # 将输入转为numpy
 y_pred = self._convert_data(inputs[0])
 y = self._convert_data(inputs[1])
 # 更新曲线
 y_pred, y, class_num, pos_label = self._precision_recall_curve_update(y_pred, y, self.class_num, self.pos_label)
 self.y_pred = y_pred
 self.y = y
 self.class_num = class_num
 self.pos_label = pos_label
 self._is_update = True
 def _roc_(self, y_pred, y, class_num, pos_label, sample_weights=None):
 if class_num == 1:
 fps, tps, thresholds = self._binary_clf_curve(y_pred, y, sample_weights=sample_weights,
 pos_label=pos_label)
 tps = np.squeeze(np.hstack([np.zeros(1, dtype=tps.dtype), tps]))
 fps = np.squeeze(np.hstack([np.zeros(1, dtype=fps.dtype), fps]))
 thresholds = np.hstack([thresholds[0][None] + 1, thresholds])
 if fps[-1] <= 0:
 raise ValueError("No negative samples in y, false positive value should be meaningless.")
 fpr = fps / fps[-1]
 if tps[-1] <= 0:
 raise ValueError("No positive samples in y, true positive value should be meaningless.")
 tpr = tps / tps[-1]
 return fpr, tpr, thresholds
  
 # 定义三个列表
 fpr, tpr, thresholds = [], [], []
 for c in range(class_num):
 preds_c = y_pred[:, c]
 res = self.roc(preds_c, y, class_num=1, pos_label=c, sample_weights=sample_weights)
 fpr.append(res[0])
 tpr.append(res[1])
 thresholds.append(res[2])
 return fpr, tpr, thresholds
 def roc(self, y_pred, y, class_num=None, pos_label=None, sample_weights=None):
 """roc"""
 y_pred, y, class_num, pos_label = self._precision_recall_curve_update(y_pred, y, class_num, pos_label)
 return self._roc_(y_pred, y, class_num, pos_label, sample_weights)
 def (self):
 """
 计算ROC曲线。返回的是一个元组，由`fpr`、 `tpr`和 `thresholds`组成的元组。
 """
 if self._is_update is False:
 raise RuntimeError('Call the update method before calling .')
 y_pred = np.squeeze(np.vstack(self.y_pred))
 y = np.squeeze(np.vstack(self.y))
 return self._roc_(y_pred, y, self.class_num, self.pos_label) 

import numpy as np
from mindspore import Tensor
from mindspore.nn.metrics import ROC
# binary classification example
x = Tensor(np.array([3, 1, 4, 2]))
y = Tensor(np.array([0, 1, 2, 3]))
metric = ROC(pos_label=2)
metric.clear()
metric.update(x, y)
fpr, tpr, thresholds = metric.()
print(fpr, tpr, thresholds)
[0., 0., 0.33333333, 0.6666667, 1.]
[0., 1, 1., 1., 1.]
[5, 4, 3, 2, 1] 

import numpy as np
from mindspore import Tensor
from mindspore.nn.metrics import ROC
# multiclass classification example
x = Tensor(np.array([[0.28, 0.55, 0.15, 0.05], [0.10, 0.20, 0.05, 0.05], [0.20, 0.05, 0.15, 0.05],0.05, 0.05, 0.05, 0.75]]))
y = Tensor(np.array([0, 1, 2, 3]))
metric = ROC(class_num=4)
metric.clear()
metric.update(x, y)
fpr, tpr, thresholds = metric.()
print(fpr, tpr, thresholds)
[array([0., 0., 0.33333333, 0.66666667, 1.]), array([0., 0.33333333, 0.33333333, 1.]), array([0., 0.33333333, 1.]), array([0., 0., 1.])]
[array([0., 1., 1., 1., 1.]), array([0., 0., 1., 1.]), array([0., 1., 1.]), array([0., 1., 1.])]
[array([1.28, 0.28, 0.2, 0.1, 0.05]), array([1.55, 0.55, 0.2, 0.05]), array([1.15, 0.15, 0.05]), array([1.75, 0.75, 0.05])] 

"""auc"""
import numpy as np
def auc(x, y, reorder=False):
 """
 使用梯形法则计算曲线下面积（AUC）。这是一个一般函数，给定曲线上的点。计算ROC曲线下的面积。
 """
 # 输入x是由ROC曲线得到的fpr值或者一个假阳性numpy数组。如果是多类的，这是一个这样的list numpy，每组代表一类。
 # 输入y是由ROC曲线得到的tpr值或者一个真阳性numpy数组。如果是多类的，这是一个这样的list numpy，每组代表一类。
 if not isinstance(x, np.ndarray) or not isinstance(y, np.ndarray):
 raise TypeError('The inputs must be np.ndarray, but got {}, {}'.format(type(x), type(y)))
 # 检查所有数组的第一个维度是否一致。检查数组中的所有对象是否具有相同的形状或长度。
 _check_consistent_length(x, y)
 # 展开列或1d numpy数组。
 x = _column_or_1d(x)
 y = _column_or_1d(y)
  
 # 进行校验
 if x.shape[0] < 2:
 raise ValueError('At least 2 points are needed to compute the AUC, but x.shape = {}.'.format(x.shape))
 direction = 1
 if reorder:
 order = np.lexsort((y, x))
 x, y = x[order], y[order]
 else:
 dx = np.diff(x)
 if np.any(dx < 0):
 if np.all(dx  1:
 raise ValueError("Found input variables with inconsistent numbers of samples: {}."
 .format([int(length) for length in lengths])) 

import numpy as np
from mindspore.nn.metrics import auc
x = Tensor(np.array([[3, 0, 1], [1, 3, 0], [1, 0, 2]]))
y = Tensor(np.array([[0, 2, 1], [1, 2, 1], [0, 0, 1]]))
metric = ROC(pos_label=1)
metric.clear()
metric.update(x, y)
fpr, tpr, thre = metric.eval()
# 利用ROC的fpr， tpr值求auc
output = auc(fpr, tpr)
print(output)
0.45