背包客研究

对机器学习中Fbeta指标的简介

对机器学习的Fbeta指标的概括介绍

Fbeta指标是一种可配置的单得分度量,用于基于对正类的预测来评价二元分类模型。

用精确度和回收率计算出Fbeta测量值。

精密是用来计算正类正确预测的百分比的度量。回忆从所有可以作出的正预测中计算出正类的正确预测的百分比。精确度最大化将最小化错误,而最大化回忆将最小化错误。

… F尺寸 按精确度和回收率的调和平均值计算,给予相同的权重。它允许使用单评分来评估模型,同时考虑到精确度和召回率,这在描述模型的性能和比较模型时是很有帮助的。

… Fbeta计量 是添加一个名为β的配置参数的F度量的泛化。默认的β值为1.0,与F度量值相同。较小的β值,如0.5,对精确度的影响更大,对回忆的影响更小,而较大的β值,如2.0,在计算评分时对精确度的影响更小,对回忆的影响更大。

当精确性和回忆性都很重要,但需要对两者给予更多的关注时,例如当错误的否定比错误的肯定或相反更重要时,使用它是一个有用的指标。

在本教程中,您将发现用于评估机器学习分类算法的Fbeta度量。

完成本教程后,你会知道:

精确度和召回率提供了两种方法来总结在二进制分类问题中为正类所犯的错误。
F测量提供了一个单一的得分,总结了精确度和召回。
Fβ-度量提供了一个可配置的F-度量版本,在计算一个积分时,多少会注意精确度和召回量。

我们开始吧。

教程概览

本教程分为三个部分:

精确和召回
1. 混淆矩阵
2. 精密
3. 回忆
F尺寸
1. 最坏的情况
2. 最佳情况
3. 50%的精确度,完美的回忆
Fbeta计量
1. F1尺寸
2. F0.5计量
3. F2测量

精确和召回

在我们深入研究Fbeta测量之前,我们必须回顾用于评估分类模型所做预测的精确度和召回量的基础。

混淆矩阵

A 混淆矩阵总结每个类的模型所做的预测的数量,以及这些预测实际上属于的类。它有助于理解模型的预测误差类型。

最简单的混淆矩阵是用于两个类别的问题,分别是负类(0类)和正类(1类)。

在这类混淆矩阵中,表中的每个单元格都有一个具体的、众所周知的名称,概括如下:

               | Positive Prediction | Negative Prediction

Positive Class | True Positive (TP) | False Negative (FN)

Negative Class | False Positive (FP) | True Negative (TN)

精确度和召回度量是根据混淆矩阵中的单元格来定义的,特别是像真正和假负这样的术语。

精确度

精确度是衡量正确的正预测数的指标。

计算方法是用正确预测的阳性案例的比率除以预测的阳性案例的总数。

精确=真实/(真实/错误)

结果是完全或完全精确的值在无精确度的0.0和1.0之间。

精确度的直觉是它不关心假底片 尽量减少错误的肯定 .我们可以用下面的一个小例子来证明这一点。

# intuition for precision

from sklearn.metrics import precision_score

# no precision

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

score = precision_score(y_true, y_pred)

print(‘No Precision: %.3f’ % score)

# some false positives

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

score = precision_score(y_true, y_pred)

print(‘Some False Positives: %.3f’ % score)

# some false negatives

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1]

score = precision_score(y_true, y_pred)

print(‘Some False Negatives: %.3f’ % score)

# perfect precision

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

score = precision_score(y_true, y_pred)

print(‘Perfect Precision: %.3f’ % score)

运行实例,验证了所有不正确和所有正确的预测类别标签的计算精度,这表明分别没有精确性和完美性。

预测一些假阳性的例子显示出精确度下降,突出表明这项措施涉及到最小化假阳性。

一个预测一些假底片的例子显示出了完美的精确度,突出表明这项措施与假底片无关。

No Precision: 0.000

Some False Positives: 0.714

Some False Negatives: 1.000

Perfect Precision: 1.000

召回率

召回率是一个度量标准,它量化了所有可能作出的正面预测中正确的正面预测的数量。

它的计算方法是,正确预测的正案例的比率除以能够预测的正案例的总数。

召回率=正确正样本/(正确正样本+错误负样本)

结果是完全或完全的召回值在未召回的0.0和完全召回的1.0之间。

召回率的直觉是它与错误的肯定无关 尽量减少虚假底片 .我们可以用下面的一个小例子来证明这一点。

# intuition for recall

from sklearn.metrics import recall_score

# no recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

score = recall_score(y_true, y_pred)

print(‘No Recall: %.3f’ % score)

# some false positives

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

score = recall_score(y_true, y_pred)

print(‘Some False Positives: %.3f’ % score)

# some false negatives

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1]

score = recall_score(y_true, y_pred)

print(‘Some False Negatives: %.3f’ % score)

# perfect recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

score = recall_score(y_true, y_pred)

print(‘Perfect Recall: %.3f’ % score)

运行该示例演示了计算所有不正确和所有正确的预测类别标签的召回,分别显示没有召回和完全召回。

预测一些错误的肯定的例子显示了完美的回忆,强调这个措施与错误的肯定无关。

预测一些假底片的例子表明召回率下降,这表明该措施与最小化假底片有关。

No Recall: 0.000

Some False Positives: 1.000

Some False Negatives: 0.600

Perfect Recall: 1.000

现在我们熟悉了精确度和召回率,让我们回顾一下F度量。

F尺寸

精确度和召回度测量两种类型的错误,可以对正类。

使精确度最大化,最大化,最小化,最小化,最小化,最小化,最大化,最大化,最大化,最大化,最大化,最大化,最大化.

F测量或F标记提供了一种方法,将精确度和召回率结合到一个单一的测量,以捕获这两个属性。

F-Measure = (2 * Precision * Recall) / (Precision + Recall)

这是调和均值两个分数中的一个。

结果是最差的F度量值为0.0,而完美的F度量值为1.0。

对F测量的直觉是,这两种测量方法都是重要的,只有很好的精确度和良好的回忆才能产生一个好的F测量方法。

最坏的情况

首先,如果所有的例子都被错误地预测,那么我们就会有零精度和零召回,从而产生一个零F度量;例如:

# worst case f-measure

from sklearn.metrics import f1_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# no precision or recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = f1_score(y_true, y_pred)

print(‘No Precision or Recall: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

运行该示例时,我们可以看到,没有精确度或召回结果的最坏情况下F度量。

No Precision or Recall: p=0.000, r=0.000, f=0.000

考虑到精确度和召回量只涉及正类,我们可以通过预测所有例子的负类来获得相同的最坏情况的精确度、召回和F度量:

# another worst case f-measure

from sklearn.metrics import f1_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# no precision and recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = f1_score(y_true, y_pred)

print(‘No Precision or Recall: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

由于没有预测阳性病例,我们必须输出一个零精度和召回,反过来,F度量。

No Precision or Recall: p=0.000, r=0.000, f=0.000

最佳情况

相反,完美的预测将会产生完美的精确度和召回率,反过来又会产生一个完美的F度量,例如：

# best case f-measure

from sklearn.metrics import f1_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# perfect precision and recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = f1_score(y_true, y_pred)

print(‘Perfect Precision and Recall: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

运行该示例,我们可以看到,完美的精确度和召回结果是一个完美的F度量。

Perfect Precision and Recall: p=1.000, r=1.000, f=1.000

50%的精确度,完美的回忆

它不可能有完美的精确度和没有回忆,或没有精确和完美的回忆。精确性和召回性都需要预测真正的积极性。

考虑一下我们预测所有案例的正类的情况。

这将给我们50%的精确度,因为一半的预测是错误的实证。它会给我们完美的回忆,因为我们不会错误的底片。

对于我们在示例中使用的平衡数据集,一半的预测是真的,一半是假的;因此,精确率是0.5%或50%。将50个感知精度和完美的回忆结合起来,将会产生一个受惩罚的F测量,特别是50%到100%的谐波平均值。

下面的例子说明了这一点。

# perfect precision f-measure

from sklearn.metrics import f1_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# perfect precision, 50% recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = f1_score(y_true, y_pred)

print(‘Result: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

运行这个例子证实了我们确实有50个感知精度和完美的召回,F得分的结果是大约0.667。

Result: p=0.500, r=1.000, f=0.667

Fbeta计量

F测量平衡了精确度和召回。

在某些问题上,我们可能会对一种更注重精确度的F度量感兴趣,比如错误肯定对最小化更重要,但错误否定仍然很重要。

在其他问题上,我们可能会对一个更注重回忆的F度量感兴趣,比如错误的否定对最小化更重要,但错误的肯定仍然很重要。

解决办法是使用Fbeta计量。

Fbeta度量是F度量的抽象,在计算中,精确度和回收率的平衡调和均值是由一个叫做* 贝塔* .

Fbeta = ((1 + beta^2) * Precision * Recall) / (beta^2 * Precision + Recall)

选择的β参数将使用名称的Fbe-计量。

例如,β值为2被称为F2测量值或F2得分。β值为1被称为F1测量值或F1得分。

β参数的三个共同值如下:

F0.5-5尺寸

(β=0.5):对精确性的重视更大,对召回的重视更少。
F1尺寸

(β=1.0):在精密度和召回量上保持平衡。
F2尺寸

(β=2.0):精确性的重量减少,召回的重量增加

起初,对不同测试值的计算的影响并不直观。

让我们仔细看看这些案例。

F1尺寸

上一节所讨论的F-措施是一个用贝塔价值为1。

具体而言,F-计量和F1-计量的计算方法相同,例如:

F-Measure = ((1 + 1^2) * Precision * Recall) / (1^2 * Precision + Recall)
F-Measure = (2 * Precision * Recall) / (Precision + Recall)

想想我们有50个感知精确和完美回忆的例子。我们可以手动计算这个情况下的F1度量如下:

F-Measure = (2 * Precision * Recall) / (Precision + Recall)
F-Measure = (2 * 0.5 * 1.0) / (0.5 + 1.0)
F-Measure = 1.0 / 1.5
F-Measure = 0.666

我们可以用功能在本网站上学习"* 贝塔* "参数设置为1.0。

完整的例子列于下文。

# calculate the f1-measure

from sklearn.metrics import fbeta_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# perfect precision, 50% recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = fbeta_score(y_true, y_pred, beta=1.0)

print(‘Result: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

运行该示例确认了完美的精确度和50%的召回率,以及0.667的F1测量值,确认了我们的计算(四舍五入)。

这个F1测量值0.667与上一节为同一情景计算的F测量值相匹配。

Result: p=0.500, r=1.000, f=0.667

F0.5-5尺寸

F0.5-5测量值是Fbeta测量值的一个例子。贝塔价值0.5。

它的效果是提高了精确度的重要性,降低了召回的重要性.

如果最大限度的精确度能最大限度地减少错误的积极性,而最大限度的回忆能最大限度地减少错误的消极性,那么 F0.5-5措施更注重最小化错误阳性 也不愿减少假底片。

F0.5-5计量的计算方法如下:

F0.5-Measure = ((1 + 0.5^2) * Precision * Recall) / (0.5^2 * Precision + Recall)
F0.5-Measure = (1.25 * Precision * Recall) / (0.25 * Precision + Recall)

考虑一下我们有50%的精确度和完美的回忆。我们可以手动计算这个情况下的F0.5度量如下:

F0.5-Measure = (1.25 * Precision * Recall) / (0.25 * Precision + Recall)
F0.5-Measure = (1.25 * 0.5 * 1.0) / (0.25 * 0.5 + 1.0)
F0.5-Measure = 0.625 / 1.125
F0.5-Measure = 0.555

鉴于精确度很低,召回率也很好,我们预计测试值为0.5将导致这个场景的得分较低。

这正是我们所看到的,在同样的情况下,F1码的计算值为0.667。精确度在计算中起着更大的作用.

我们可以确认这一计算,完整的例子如下。

# calculate the f0.5-measure

from sklearn.metrics import fbeta_score

from sklearn.metrics import f1_score

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

# perfect precision, 50% recall

y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

y_pred = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

p = precision_score(y_true, y_pred)

r = recall_score(y_true, y_pred)

f = fbeta_score(y_true, y_pred, beta=0.5)

print(‘Result: p=%.3f, r=%.3f, f=%.3f’ % (p, r, f))

运行该示例确认精确度和召回值,然后报告0.556的F0.5度量值(带四舍五入),与我们手动计算的值相同。

Result: p=0.500, r=1.000, f=0.556

F2尺寸

F2测量值是Fbeta测量值的一个例子,其中包括贝塔价值2.0。

它的作用是降低了精确度的重要性,增加了召回的重要性.

如果最大限度的精确度能最大限度地减少错误的积极性,而最大限度的回忆能最大限度地减少错误的消极性,那么 F2计量更注重最小化假底片 也不愿减少错误的积极性。

F2计量方法计算如下:

F2-Measure = ((1 + 2^2) * Precision * Recall) / (2^2 * Precision + Recall)
F2-Measure = (5 * Precision * Recall) / (4 * Precision + Recall)

考虑一下我们有50%的精确度和完美的回忆。

我们可以手动计算这个情况下的F2测量如下:

F2-Measure = (5 * Precision * Recall) / (4 * Precision + Recall)
F2-Measure = (5 * 0.5 * 1.0) / (4 * 0.5 + 1.0)
F2-Measure = 2.5 / 3.0
F2-Measure = 0.833

我们希望贝塔由于召回有一个完美的评分,2.0值将会使这个场景的得分更高,这将会比精确度低的得分更高。

这正是我们所看到的,在同样的情况下,用0.667计算出的F1分数,可以实现0.833的F2测量值。回忆在计算中扮演了更重要的角色。