sklearn中分类模型评估指标（四）：Jaccard相似系数、铰链损失、对数损失

Jaccard相似系数

jaccard_score函数计算标签集对之间的 Jaccard 相似系数的平均值，也称为 Jaccard 指数。

第 i 个样本的 Jaccard 相似系数，具有真实标签集yiy_iyi和预测标签集y^i\hat{y}_iy^i，其公式定义为：

J(yi,y^i)=∣yi∩y^i∣∣yi∪y^i∣.J(y_i, \hat{y}_i) = \frac{|y_i \cap \hat{y}_i|}{|y_i \cup \hat{y}_i|}.J(yi,y^i)=∣yi∪y^i∣∣yi∩y^i∣.

jaccard_score的工作原理与precision_recall_fscore_support类似，它是一种集合式度量方式，适用于二分类问题，并可以通过使用average参数扩展到适用于多标签和多分类场景。

二分类场景的示例代码如下：

import numpy as np
from sklearn.metrics import jaccard_score
y_true = np.array([[0, 1, 1],
                   [1, 1, 0]])
y_pred = np.array([[1, 1, 1],
                   [1, 0, 0]])
print(jaccard_score(y_true[0], y_pred[0]))
print(jaccard_score(y_true[1], y_pred[1]))
复制代码

运行结果：

0.6666666666666666
0.5
复制代码

在具有二标签指示器的多标签场景下：

# (0.5+0.66666)/2 = 0.58333
print(jaccard_score(y_true, y_pred, average='samples'))
# (1/2+1/2+2/2)/3
print(jaccard_score(y_true, y_pred, average='macro'))
print(jaccard_score(y_true, y_pred, average=None))
复制代码

运行结果：

0.5833333333333333
0.6666666666666666
[0.5 0.5 1. ]
复制代码

多分类问题被二值化并像多标签问题一样处理：

y_pred = [0, 2, 1, 2]
y_true = [0, 1, 2, 2]
print(jaccard_score(y_true, y_pred, average=None)) # 1/1  0/2 1/3
print(jaccard_score(y_true, y_pred, average='macro')) # (1+0.333)/3=0.444
print(jaccard_score(y_true, y_pred, average='micro')) # (1+1)/(1+2+3)
复制代码

运行结果：

[1.         0.         0.33333333]
0.4444444444444444
0.3333333333333333
复制代码

铰链损失（Hinge loss）

hinge_loss函数使用铰链损失计算模型与数据之间的平均距离，铰链损失是一种仅考虑预测误差的单边度量。（铰链损失用于最大边缘分类器，例如支持向量机。）

如果标签用+1和-1编码，y是真实值，w是decision_function输出的预测决策，则铰链损失定义为：

LHinge(y,w)=max⁡{1−wy,0}=∣1−wy∣+L_\text{Hinge}(y, w) = \max\left\{1 - wy, 0\right\} = \left|1 - wy\right|_+LHinge(y,w)=max{1−wy,0}=∣1−wy∣+

如果有两个以上的标签，hinge_loss使用多分类变体。

如果 ywy_wyw 是真实标签的预测决策，yty_tyt 是所有其他标签的预测决策的最大值，其中预测决策由决策函数输出，则多分类铰链损失定义为：

LHinge(yw,yt)=max⁡{1+yt−yw,0}L_\text{Hinge}(y_w, y_t) = \max\left\{1 + y_t - y_w, 0\right\}LHinge(yw,yt)=max{1+yt−yw,0}

这里有一个小例子，演示了二分类问题中在svm分类器下使用铰链损失函数：

from sklearn import svm
from sklearn.metrics import hinge_loss
X = [[0], 
     [1]]
y = [-1, 1]
est = svm.LinearSVC(random_state=0)
est.fit(X, y)
pred_decision = est.decision_function([[-2], 
                                       [3], 
                                       [0.5]])
print(pred_decision)
print(hinge_loss([-1, 1, 1], pred_decision))
复制代码

运行结果：

[-2.18177944  2.36355888  0.09088972]
0.3030367603854425
复制代码

这是一个示例，演示了在多分类问题中在带有svm分类器下使用铰链损失函数：

X = np.array([[0], 
              [1], 
              [2], 
              [3]])
Y = np.array([0, 1, 2, 3])
labels = np.array([0, 1, 2, 3])
est = svm.LinearSVC()
est.fit(X, Y)
pred_decision = est.decision_function([[-1], 
                                       [2], 
                                       [3]])
print(pred_decision)
y_true = [0, 2, 3]
print(hinge_loss(y_true, pred_decision, labels=labels))
复制代码

运行结果：

[[ 1.27270694  0.03417093 -0.68376942 -1.4016749 ]
 [-1.45454139 -0.58116657 -0.37610526 -0.17099403]
 [-2.36362417 -0.78627908 -0.27355054  0.23923292]]
0.5641092543547738
复制代码

对数损失（Log loss）

对数损失，也称为逻辑回归损失或交叉熵损失，是在概率估计上定义的。 它通常用于 （多项式）逻辑回归 和 神经网络 ，以及期望最大化（expectation-maximization，EM算法）的一些变体，并且可用于评估分类器的概率输出（predict_proba）而不是其离散预测。

对于具有真实标签 y∈{0,1}y \in \{0,1\}y∈{0,1} 和概率估计 p=Pr⁡(y=1)p = \operatorname{Pr}(y = 1)p=Pr(y=1) 的二分类，每个样本的对数损失是给定真实标签的分类器的负对数似然：

Llog⁡(y,p)=−log⁡Pr⁡(y∣p)=−(ylog⁡(p)+(1−y)log⁡(1−p))L_{\log}(y, p) = -\log \operatorname{Pr}(y|p) = -(y \log (p) + (1 - y) \log (1 - p))Llog(y,p)=−logPr(y∣p)=−(ylog(p)+(1−y)log(1−p))

从二分类扩展到多分类情况如下，让一组样本的真实标签被编码为1到K的二元指示矩阵Y，即，如果样本i的标签k来自一组K个标签，则yi,k=1y_{i,k} = 1yi,k=1。令P为概率估计矩阵，其中，pi,k=Pr⁡(yi,k=1)p_{i,k} = \operatorname{Pr}(y_{i,k} = 1)pi,k=Pr(yi,k=1) 。 那么整个集合的对数损失为：

Llog⁡(Y,P)=−log⁡Pr⁡(Y∣P)=−1N∑i=0N−1∑k=0K−1yi,klog⁡pi,kL_{\log}(Y, P) = -\log \operatorname{Pr}(Y|P) = - \frac{1}{N} \sum_{i=0}^{N-1} \sum_{k=0}^{K-1} y_{i,k} \log p_{i,k}Llog(Y,P)=−logPr(Y∣P)=−N1i=0∑N−1k=0∑K−1yi,klogpi,k

要了解这如何概括上面给出的二元对数损失，请注意在二分类情况下，pi,0=1−pi,1p_{i,0} = 1 - p_{i,1}pi,0=1−pi,1 和 yi,0=1−yi,1y_{i,0} = 1 - y_{i,1}yi,0=1−yi,1，因此，在 yi,k∈{0,1}y_{i,k} \in \{0,1\}yi,k∈{0,1} 上扩展内部总和给出二元对数损失。

log_loss函数计算对数损失，根据估计器的predict_proba方法返回的真实标签列表和概率矩阵。

示例代码：

from sklearn.metrics import log_loss
y_true = [0, 0, 1, 1]
y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
print(log_loss(y_true, y_pred))
复制代码

运行结果：

0.1738073366910675
复制代码

其中，y_pred 中的第一个[.9, .1]表示第一个样本的标签为 0 的概率为 90%。对数损失是非负的。

总结