Fbeta-Measure 是一种用于评估二元分类模型性能的可配置单评分指标，它基于对正类的预测结果。
Fbeta-Measure 的计算依赖于精确率（Precision）和召回率（Recall）。
精确率（Precision）是衡量模型在预测为正类的情况下，有多少真实样本也是正类的指标。召回率（Recall）是衡量模型找出所有真实正类样本的能力。提高精确率可以减少假阳性错误，而提高召回率可以减少假阴性错误。
F-Measure （或 F-Score）是精确率和召回率的调和平均数，两者具有相同的权重。它能够通过单一分数同时考虑模型的精确率和召回率，这有助于描述模型性能和比较模型。
Fbeta-Measure 是 F-Measure 的泛化，增加了一个名为 beta 的配置参数。默认的 beta 值为 1.0，这与 F-Measure 相同。较小的 beta 值（例如 0.5）会更侧重于精确率，而较少的侧重于召回率；反之，较大的 beta 值（例如 2.0）则会更侧重于召回率，而较少的侧重于精确率。
当精确率和召回率都很重要，但需要对其中一个略微多加关注时，Fbeta-Measure 非常有用。例如，当假阴性比假阳性更重要，或者反之亦然。
在本教程中，您将学习 Fbeta-Measure，以评估机器学习分类算法的性能。
完成本教程后，您将了解：
- 精确率和召回率提供了两种总结二元分类问题中正类预测错误的方法。
- F-Measure 提供了一个单一的分数来总结精确率和召回率。
- Fbeta-Measure 提供了一个可配置版本的 F-Measure，在计算单一分数时，可以对精确率和召回率测量给予更多或更少的关注。
启动您的项目，阅读我的新书《Python 中的不平衡分类》，其中包含分步教程和所有示例的Python源代码文件。
让我们开始吧。
Fbeta-Measure 机器学习简介
照片由 Marco Verch 拍摄，保留部分权利。
教程概述
本教程分为三个部分；它们是：
- 精确率和召回率
- 混淆矩阵
- 精确率
- 回顾
- F-Measure
- 最差情况
- 最佳情况
- 50% 精确率，完美召回率
- Fbeta-Measure
- F1-Measure
- F0.5 Measure
- F2 Measure
精确率和召回率
在深入探讨 Fbeta-Measure 之前，我们必须回顾用于评估分类模型预测的精确率和召回率指标的基础知识。
混淆矩阵
一个 混淆矩阵 总结了模型对每个类的预测数量，以及这些预测实际所属的类。它有助于理解模型产生的预测错误类型。
最简单的混淆矩阵适用于二分类问题，包含负类（类别 0）和正类（类别 1）。
在此类混淆矩阵中，表格中的每个单元格都有一个特定且易于理解的名称，总结如下：
|
1 2 3 |
| 正向预测 | 负向预测 正类别 | 真阳性 (TP) | 假阴性 (FN) 负类别 | 假阳性 (FP) | 真阴性 (TN) |
精确率和召回率指标根据混淆矩阵中的单元格定义，特别是像真正例（true positives）和假阴例（false negatives）这样的术语。
精确率
精确率是量化正确正向预测数量的指标。
计算方法是：正确预测的正例数量除以总共预测的正例数量。
- 精确率 = 真阳性 / (真阳性 + 假阳性)
结果是一个介于 0.0（无精确率）到 1.0（完全或完美精确率）之间的值。
精确率的直观理解是，它不关心假阴例，而是最小化假阳性。我们可以通过下面的小例子来演示这一点。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# 精确率的直观理解 from sklearn.metrics import precision_score # 无精确率 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('无精确率: %.3f' % score) # 一些假阳性 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('一些假阳性: %.3f' % score) # 一些假阴性 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('一些假阴性: %.3f' % score) # 完美精确率 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('完美精确率: %.3f' % score) |
运行示例演示了计算所有错误和所有正确预测的类标签的精确率，分别显示了无精确率和完美精确率。
预测一些假阳性的示例显示精确率下降，突显了该度量关注最小化假阳性。
预测一些假阴性的示例显示完美精确率，突显了该度量不关注假阴性。
|
1 2 3 4 |
无精确率: 0.000 一些假阳性: 0.714 一些假阴性: 1.000 完美精确率: 1.000 |
回顾
召回率是量化所有可能做出的正向预测中正确正向预测数量的指标。
计算方法是：正确预测的正例数量除以总共可能预测到的正例数量。
- 召回率 = 真阳性 / (真阳性 + 假阴性)
结果是一个介于 0.0（无召回）到 1.0（完全或完美召回）之间的值。
召回率的直观理解是，它不关心假阳性，而是最小化假阴性。我们可以通过下面的小例子来演示这一点。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# 召回率的直观理解 from sklearn.metrics import recall_score # 无召回率 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('无召回率: %.3f' % score) # 一些假阳性 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('一些假阳性: %.3f' % score) # 一些假阴性 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('一些假阴性: %.3f' % score) # 完美召回率 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('完美召回率: %.3f' % score) |
运行示例演示了计算所有错误和所有正确预测的类标签的召回率，分别显示了无召回率和完美召回率。
预测一些假阳性的示例显示完美召回率，突显了该度量不关注假阳性。
预测一些假阴性的示例显示召回率下降，突显了该度量关注最小化假阴性。
|
1 2 3 4 |
无召回率: 0.000 一些假阳性: 1.000 一些假阴性: 0.600 完美召回率: 1.000 |
现在我们熟悉了精确率和召回率，让我们回顾一下 F-Measure。
想要开始学习不平衡分类吗？
立即参加我为期7天的免费电子邮件速成课程（附示例代码）。
点击注册，同时获得该课程的免费PDF电子书版本。
F-Measure
精确率和召回率衡量了可能针对正类出现的两种错误。
最大化精确率可最小化假阳性，最大化召回率可最小化假阴性。
F-Measure 或 F-Score 提供了一种将精确率和召回率结合为单一度量的方法，该度量能同时捕捉两者的特性。
- F 值 = (2 * 精确率 * 召回率) / (精确率 + 召回率)
这是这两个分数的 调和平均数。
结果是一个介于 0.0（最差 F-Measure）和 1.0（完美 F-Measure）之间的值。
F-Measure 的直观理解是，这两种度量具有相等的权重，只有同时具有良好的精确率和良好的召回率才能获得良好的 F-Measure。
最差情况
首先，如果所有样本都被错误地完美预测，我们将得到零精确率和零召回率，从而得到零 F-Measure；例如
|
1 2 3 4 5 6 7 8 9 10 11 |
# 最差情况 F-Measure from sklearn.metrics import f1_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score # 无精确率或召回率 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('无精确率或召回率: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例，我们可以看到无精确率或召回率导致了最差情况的 F-Measure。
|
1 |
无精确率或召回率: p=0.000, r=0.000, f=0.000 |
考虑到精确率和召回率都只关注正类，我们通过将所有样本预测为负类来达到相同的最差情况精确率、召回率和 F-Measure。
|
1 2 3 4 5 6 7 8 9 10 11 |
# 另一个最差情况 F-Measure from sklearn.metrics import f1_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score # 无精确率和召回率 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('无精确率或召回率: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
由于没有预测到任何正类，我们必须输出零精确率和零召回率，进而得到零 F-Measure。
|
1 |
无精确率或召回率: p=0.000, r=0.000, f=0.000 |
最佳情况
反之，完美的预测将导致完美的精确率和召回率，进而得到完美的 F-Measure，例如
|
1 2 3 4 5 6 7 8 9 10 11 |
# 最佳情况 F-Measure from sklearn.metrics import f1_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score # 完美的精确率和召回率 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('完美的精确率和召回率: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例，我们可以看到完美的精确率和召回率导致了完美的 F-Measure。
|
1 |
完美的精确率和召回率: p=1.000, r=1.000, f=1.000 |
50% 精确率，完美召回率
不可能出现完美精确率但无召回率，或无精确率但完美召回率。精确率和召回率都需要预测到真正例。
考虑我们将所有情况都预测为正类的情况。
这将导致 50% 的精确率，因为一半的预测是假阳性。它将得到完美的召回率，因为我们没有假阴性。
对于我们在示例中使用的数据集，一半的预测将是真正例，一半将是假阳性；因此，精确率比例将是 0.5 或 50%。将 50% 的精确率与完美的召回率结合将导致 F-Measure 被扣分，具体来说是 50% 和 100% 之间的调和平均数。
以下示例将演示这一点。
|
1 2 3 4 5 6 7 8 9 10 11 |
# 完美精确率 F-Measure from sklearn.metrics import f1_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score # 完美精确率，50% 召回率 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('结果: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例证实我们确实得到了 50% 的精确率和完美的召回率，而 F-Score 的结果约为 0.667。
|
1 |
结果: p=0.500, r=1.000, f=0.667 |
Fbeta-Measure
F-Measure 平衡了精确率和召回率。
在某些问题中，我们可能对更侧重精确率的 F-Measure 感兴趣，例如当假阳性需要尽量减少，但假阴性仍然重要时。
在其他问题中，我们可能对更侧重召回率的 F-Measure 感兴趣，例如当假阴性需要尽量减少，但假阳性仍然重要时。
解决方案是 Fbeta-Measure。
Fbeta-Measure 是 F-Measure 的一种抽象，其中精确率和召回率在 调和平均数 计算中的权重由一个称为 *beta* 的系数控制。
- Fbeta = ((1 + beta^2) * Precision * Recall) / (beta^2 * Precision + Recall)
beta 参数的选择将用于 Fbeta-Measure 的名称中。
例如，beta 值为 2 被称为 F2-Measure 或 F2-Score。beta 值为 1 被称为 F1-Measure 或 F1-Score。
beta 参数的三个常见值如下：
- F0.5-Measure (beta=0.5): 更侧重精确率，降低召回率的重要性。
- F1-Measure (beta=1.0): 平衡精确率和召回率的权重。
- F2-Measure (beta=2.0): 降低精确率的重要性，提高召回率。
不同 beta 值对计算的影响起初可能并不直观。
让我们仔细看看每种情况。
F1-Measure
前面章节讨论的 F-Measure 是 Fbeta-Measure 的一个例子，其中 *beta* 值为 1。
具体来说，F-Measure 和 F1-Measure 计算的是同一件事；例如
- F-Measure = ((1 + 1^2) * Precision * Recall) / (1^2 * Precision + Recall)
- F 值 = (2 * 精确率 * 召回率) / (精确率 + 召回率)
考虑我们有 50% 精确率和完美召回率的情况。我们可以按如下方式手动计算此情况下的 F1-Measure：
- F 值 = (2 * 精确率 * 召回率) / (精确率 + 召回率)
- F-Measure = (2 * 0.5 * 1.0) / (0.5 + 1.0)
- F-Measure = 1.0 / 1.5
- F-Measure = 0.666
我们可以使用 scikit-learn 中的 fbeta_score() 函数 来验证此计算，并将“beta”参数设置为 1.0。
完整的示例如下所示。
|
1 2 3 4 5 6 7 8 9 10 11 |
# 计算 F1-Measure from sklearn.metrics import fbeta_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score # 完美精确率，50% 召回率 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('结果: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例确认了完美精确率和 50% 召回率以及 0.667 的 F1-Measure，与我们之前的计算结果一致（考虑四舍五入）。
这个 F1-Measure 值 0.667 与上一节中为同一场景计算的 F-Measure 值匹配。
|
1 |
结果: p=0.500, r=1.000, f=0.667 |
F0.5-Measure
F0.5-measure 是 Fbeta-Measure 的一个例子，其中 *beta* 值为 0.5。
它会提高精确率的重要性，降低召回率的重要性。
如果最大化精确率可以最小化假阳性，最大化召回率可以最小化假阴性，那么 **F0.5-Measure 更侧重于最小化假阳性**，而不是最小化假阴性。
F0.5-Measure 的计算如下：
- 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-Measure：
- 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
我们预计 beta 值为 0.5 会导致此场景的分数较低，因为精确率得分较低而召回率得分极佳。
这正是我们所看到的，对于 F1-Score 为 0.667 的同一场景，F0.5-Measure 达到了 0.555。精确率在计算中起到了更大的作用。
我们可以验证此计算；完整的示例列在下面。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 计算 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 # 完美精确率，50% 召回率 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('结果: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例证实了精确率和召回率值，然后报告 F0.5-Measure 为 0.556（四舍五入后），与我们手动计算的值相同。
|
1 |
结果: p=0.500, r=1.000, f=0.556 |
F2-Measure
F2-Measure 是 Fbeta-Measure 的一个例子，其中 *beta* 值为 2.0。
它会降低精确率的重要性，提高召回率的重要性。
如果最大化精确率可以最小化假阳性，最大化召回率可以最小化假阴性，那么 **F2-Measure 更侧重于最小化假阴性**，而不是最小化假阳性。
F2-Measure 的计算如下：
- F2-Measure = ((1 + 2^2) * Precision * Recall) / (2^2 * Precision + Recall)
- F2-Measure = (5 * Precision * Recall) / (4 * Precision + Recall)
考虑我们有 50% 精确率和完美召回率的情况。
我们可以按如下方式手动计算此情况下的 F2-Measure：
- 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
我们预计 *beta* 值为 2.0 会导致此场景的分数更高，因为召回率得分完美，这将比精确率的糟糕表现更受推崇。
这正是我们所看到的，对于 F1-Score 为 0.667 的同一场景，F2-Measure 达到了 0.833。召回率在计算中起到了更大的作用。
我们可以验证此计算；完整的示例列在下面。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 计算 F2-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 # 完美精确率，50% 召回率 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=2.0) print('结果: p=%.3f, r=%.3f, f=%.3f' % (p, r, f)) |
运行示例证实了精确率和召回率值，然后报告 F2-Measure 为 0.833，与我们手动计算的值相同（考虑四舍五入）。
|
1 |
结果: p=0.500, r=1.000, f=0.833 |
进一步阅读
如果您想深入了解，本节提供了更多关于该主题的资源。
教程
论文
- F-Measure 的真相, 2007.
API
文章
总结
在本教程中，您学习了 Fbeta-Measure，用于评估机器学习分类算法的性能。
具体来说，你学到了：
- 精确率和召回率提供了两种总结二元分类问题中正类预测错误的方法。
- F-Measure 提供了一个单一的分数来总结精确率和召回率。
- Fbeta-Measure 提供了一个可配置版本的 F-Measure，在计算单一分数时，可以对精确率和召回率测量给予更多或更少的关注。
你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。
掌控不平衡分类！
在几分钟内开发不平衡学习模型
...只需几行python代码
在我的新电子书中探索如何实现
使用 Python 处理不平衡分类问题
它提供了关于以下内容的自学教程和端到端项目：
性能指标、欠采样方法、SMOTE、阈值移动、概率校准、成本敏感算法
以及更多...
我的助教给我的一个关于精确率和召回率的简单解释，来自实验室练习
(可能引起不适：狩猎)
让我们考虑一个情况，您正在狩猎鹿，但也有麋鹿。您看到像鹿的东西，然后开枪。精确率是您（成功？）射中的鹿与总击杀数之比。它衡量您开枪后射击的“精确度”。它不考虑鹿的总数。
现在让我们考虑您首先用鹿的叫声引诱它们，然后射击任何有反应的。召回率是“响应”该叫声的鹿与可能响应诱饵的总鹿数之比。“响应”听起来很像“召回”，并且是针对可能响应诱饵的总数来衡量的。它不考虑有多少麋鹿响应了。
从那里开始就很明显了，如果我们的模型很保守，并且很少“开枪”，它将具有很高的精确率但召回率很差。另一方面，如果它几乎“开枪”所有目标，召回率会很高，但精确度会远不如。
我承认这个解释有点暴力 :') 但它非常有意义，以至于我认为我永远不会忘记它。
感谢分享。
我理解这可能取决于具体情况。例如，对于一家银行使用模型来检测欺诈交易——可能不一定想要高假阳性率。因此，F0.5、F1 可能更合适。
而在其他情况下，当假阳性的成本微不足道，而将某物归类为假阴性会产生巨大成本时，F2 可能更合适。
鉴于以上情况，您如何决定 Beta 的合适值？有什么指导原则可以使用吗？
好问题，请尝试本教程中的方法
https://machinelearning.org.cn/tour-of-evaluation-metrics-for-imbalanced-classification/
我有一个关于 F Beta 衡量标准的问题。对于具有不同平衡度的大量不同数据集，将其保持为静态数字（0.5、1、2）是否有意义，还是应使用动态值？
示例 1. 如果我们有一个包含 50 个 1 和 50 个 0 的数据集，在这种情况下，f1 分数（也称为 F1 分数）可能很有意义，因为我们希望训练一个模型，不仅要能准确预测 1（精确率），还要能够根据数据集中大量的机会进行一定数量的 1 预测。过分侧重于精确率会错过机会，尽管预测更精确。模型可以优化以获得均衡的 F1 分数。
示例 2. 一个包含 4 个 1 和 96 个 0 的数据集。由于 1 的数量稀少，这个模型应该几乎只侧重于精确率（如果误报的成本很高）。我的想法是设置 fbeta = (1 的总和 / 0 的总和)，即 4/96，或 0.04。这将动态设置模型的 fbeta 分数，以更好地适应数据集。（尽管现在写出来，这是否可能是一种前瞻性偏差？）
示例 3. 96 个 1 和 4 个 0。这个模型几乎可以完全依赖召回率，因为假设数据集中有大量的 1 的机会（96/4 = fbeta 为 24）。这意味着模型可以更自由地选择 1。
非常想听听您的想法。我个人认为，如果我们更关心正确预测 1，那么 fbeta 为 0.5 会是最佳选择，这样就不会引入前瞻性偏差？
谢谢！仍然非常喜欢这个网站。
为了在同一个数据集上比较算法，beta 必须是恒定的。
可以根据数据集调整 beta，但不要跨数据集比较算法。
如何将 Fbeta 测量应用于多类问题？
我相信您可以直接使用，只要您将正类和负类定义/分组在一起即可，请参见此文档
https://scikit-learn.cn/stable/modules/generated/sklearn.metrics.fbeta_score.html
B=0.5 的作用是提高精确率的重要性并降低召回率的重要性。
B=2 的作用是提高召回率的重要性并降低精确率的重要性。
这个说法与公式相悖，但所有博客都有这个说法，但没有进一步解释它与公式是如何关联的。
我们在分母中乘以 beta 和精确率，所以精确率值增加，召回率保持不变。
所以无论是 beta=0.5 还是 beta=2，都会提高精确率的重要性，对吗？因为精确率是与 beta 相乘的值。
Mark，我同意你得出的结论。
在您从 F1 测量开始的代码示例中，您提到
# 完美精确率，50% 召回率
y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
y_pred = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
我认为，这应该是 50% 的精确率，完美的召回率。您下面也是这么说的
结果：p=0.500, r=1.000,
这让我感到困惑了一秒钟，但感谢这篇很棒的文章。
谢谢你的反馈 Frederic！
+1 – 我开始怀疑我的理解了 :)
您好，当我们用 0.1 到 0.9 之间的 beta 值相乘时，它会提高精确率的重要性并降低召回率的重要性。
如果 beta 值在 2 到 10 之间，它会提高精确率的重要性并降低召回率的重要性。
最终，这些 Beta 测量会提高 F 分数或 F 测量值，因为我们乘以了某个值……但它不会真正提高召回率或精确率，也不会改变 FP 和 FN 总数的事实。那么，为什么我们对提高 F 测量值感兴趣或关注它呢？
请解释一下……
您好 muthu……以下资源可能会帮助您更清楚地理解
https://towardsdatascience.com/the-f1-score-bec2bbc38aa6