► Keras 3 API 文档 / 指标 / 基于真/假阳性和阴性的分类指标

基于真/假阳性和阴性的分类指标

`AUC` 类

keras.metrics.AUC(
    num_thresholds=200,
    curve="ROC",
    summation_method="interpolation",
    name=None,
    dtype=None,
    thresholds=None,
    multi_label=False,
    num_labels=None,
    label_weights=None,
    from_logits=False,
)

近似 ROC 或 PR 曲线的 AUC（曲线下面积）。

ROC（受试者工作特征）或 PR（精确率-召回率）曲线的 AUC（曲线下面积）是二元分类器的质量度量。与准确率不同，但与交叉熵损失类似，ROC-AUC 和 PR-AUC 评估模型的所有操作点。

此类使用黎曼和来近似 AUC。在指标累积阶段，预测值按值累积在预定义的桶内。然后通过对每个桶的平均值进行插值来计算 AUC。这些桶定义了评估的操作点。

此指标创建四个局部变量，true_positives、true_negatives、false_positives 和 false_negatives，用于计算 AUC。为了离散化 AUC 曲线，使用一组线性间隔的阈值来计算召回率和精确率值的对。因此，ROC 曲线下的面积使用召回值的高度乘以假阳性率来计算，而 PR 曲线下的面积使用精确值的高度乘以召回率来计算。

此值最终作为 auc 返回，它是一个幂等操作，计算精确率与召回率值的离散曲线下的面积（使用上述变量计算）。num_thresholds 变量控制离散化的程度，阈值数量越大，对真实 AUC 的逼近程度越高。逼近的质量可能会根据 num_thresholds 的值而发生巨大变化。thresholds 参数可用于手动指定阈值，以便更均匀地分割预测。

为了获得真实 AUC 的最佳逼近，predictions 应近似均匀地分布在范围 [0, 1] 内（如果 from_logits=False）。如果不是这种情况，AUC 近似的质量可能会很差。将 summation_method 设置为“minoring”或“majoring”可以通过提供 AUC 的下限或上限估计来帮助量化近似中的误差。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

参数

num_thresholds：（可选）离散化 ROC 曲线时使用的阈值数量。值必须 > 1。默认为 200。
curve：（可选）指定要计算的曲线的名称，'ROC'（默认）或 'PR'（表示精确率-召回率曲线）。
summation_method：（可选）指定使用的黎曼求和方法。“interpolation”（默认）对 ROC 应用中点求和方案。对于 PR-AUC，对（真/假）阳性进行插值，但不插值精确率（有关详细信息，请参阅 Davis & Goadrich 2006）；“minoring”对递增的区间应用左求和，对递减的区间应用右求和；“majoring”则相反。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。
thresholds：（可选）用作离散化曲线的阈值的浮点值列表。如果设置，则忽略 num_thresholds 参数。值应在 [0, 1] 范围内。端点阈值等于 {-epsilon, 1+epsilon}（其中 epsilon 是一个小的正值）将自动包含在内，以便正确处理正好等于 0 或 1 的预测。
multi_label：布尔值，指示是否应将多标签数据视为如此，其中为每个标签单独计算 AUC，然后跨标签取平均值；或者（当为 False 时）是否应将数据展平为单个标签，然后再进行 AUC 计算。在后一种情况下，当多标签数据传递给 AUC 时，每个标签-预测对都被视为一个单独的数据点。对于多类数据，应将其设置为 False。
num_labels：（可选）标签的数量，当 multi_label 为 True 时使用。如果未指定 num_labels，则会在第一次调用 update_state 时创建状态变量。
label_weights：（可选）用于计算多标签数据的 AUC 的非负权重列表、数组或张量。当 multi_label 为 True 时，权重将应用于各个标签的 AUC，当它们取平均值以生成多标签 AUC 时。当为 False 时，它们用于在计算展平数据上的混淆矩阵时对各个标签预测进行加权。请注意，这与 class_weights 不同，因为 class_weights 根据示例的标签值对示例进行加权，而 label_weights 仅取决于展平之前该标签的索引；因此，label_weights 不应用于多类数据。
from_logits：布尔值，指示预测（update_state 中的 y_pred）是概率还是 Sigmoid 对数。根据经验，当使用 Keras 损失时，损失的 from_logits 构造函数参数应与 AUC 的 from_logits 构造函数参数匹配。

示例

>>> m = keras.metrics.AUC(num_thresholds=3)
>>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9])
>>> # threshold values are [0 - 1e-7, 0.5, 1 + 1e-7]
>>> # tp = [2, 1, 0], fp = [2, 0, 0], fn = [0, 1, 2], tn = [0, 2, 2]
>>> # tp_rate = recall = [1, 0.5, 0], fp_rate = [1, 0, 0]
>>> # auc = ((((1 + 0.5) / 2) * (1 - 0)) + (((0.5 + 0) / 2) * (0 - 0)))
>>> #     = 0.75
>>> m.result()
0.75

>>> m.reset_state()
>>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9],
...                sample_weight=[1, 0, 0, 1])
>>> m.result()
1.0

与 compile() API 一起使用

# Reports the AUC of a model outputting a probability.
model.compile(optimizer='sgd',
              loss=keras.losses.BinaryCrossentropy(),
              metrics=[keras.metrics.AUC()])

# Reports the AUC of a model outputting a logit.
model.compile(optimizer='sgd',
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.AUC(from_logits=True)])

[源代码]

`Precision` 类

keras.metrics.Precision(
    thresholds=None, top_k=None, class_id=None, name=None, dtype=None
)

计算预测相对于标签的精确率。

该指标创建两个局部变量，true_positives 和 false_positives，用于计算精确率。此值最终作为 precision 返回，这是一个幂等操作，它仅将 true_positives 除以 true_positives 和 false_positives 的总和。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果设置了 top_k，我们将计算精确率，即批次条目的预测值最高的 top-k 个类中的一个类平均正确的频率，并且可以在该条目的标签中找到该类。

如果指定了 class_id，则我们通过仅考虑批次中 class_id 高于阈值和/或在 top-k 个最高预测中的条目来计算精确率，并计算其中 class_id 确实是正确标签的条目的分数。

参数

thresholds：（可选）浮点值，或 [0, 1] 中浮点阈值的 Python 列表/元组。将阈值与预测值进行比较以确定预测的真值（即，高于阈值则为 True，低于阈值则为 False）。如果与设置了 from_logits=True（即，未对预测应用 Sigmoid）的损失函数一起使用，则应将 thresholds 设置为 0。为每个阈值生成一个指标值。如果既未设置 thresholds 也未设置 top_k，则默认使用 thresholds=0.5 计算精确率。
top_k：（可选）默认情况下未设置。一个整数值，指定计算精确率时要考虑的 top-k 个预测。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.Precision()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
>>> m.result()
0.6666667

>>> m.reset_state()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

>>> # With top_k=2, it will calculate precision over y_true[:2]
>>> # and y_pred[:2]
>>> m = keras.metrics.Precision(top_k=2)
>>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])
>>> m.result()
0.0

>>> # With top_k=4, it will calculate precision over y_true[:4]
>>> # and y_pred[:4]
>>> m = keras.metrics.Precision(top_k=4)
>>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])
>>> m.result()
0.5

与 compile() API 一起使用

model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=[keras.metrics.Precision()])

与 from_logits=True 的损失一起使用

model.compile(optimizer='adam',
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.Precision(thresholds=0)])

[源代码]

`Recall` 类

keras.metrics.Recall(
    thresholds=None, top_k=None, class_id=None, name=None, dtype=None
)

计算预测相对于标签的召回率。

此指标创建两个局部变量，true_positives 和 false_negatives，用于计算召回率。此值最终作为 recall 返回，这是一个幂等操作，它仅将 true_positives 除以 true_positives 和 false_negatives 的总和。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果设置了 top_k，则召回率将计算为批次条目的标签中的一个类平均出现在 top-k 个预测中的频率。

如果指定了 class_id，则我们通过仅考虑批次中 class_id 在标签中的条目来计算召回率，并计算其中 class_id 高于阈值和/或在 top-k 个预测中的条目的分数。

参数

thresholds：（可选）浮点值，或 [0, 1] 中浮点阈值的 Python 列表/元组。将阈值与预测值进行比较以确定预测的真值（即，高于阈值则为 True，低于阈值则为 False）。如果与设置了 from_logits=True（即，未对预测应用 Sigmoid）的损失函数一起使用，则应将 thresholds 设置为 0。为每个阈值生成一个指标值。如果既未设置 thresholds 也未设置 top_k，则默认使用 thresholds=0.5 计算召回率。
top_k: (可选) 默认未设置。一个整数值，指定计算召回率时要考虑的前 k 个预测结果。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.Recall()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
>>> m.result()
0.6666667

>>> m.reset_state()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

与 compile() API 一起使用

model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=[keras.metrics.Recall()])

与 from_logits=True 的损失一起使用

model.compile(optimizer='adam',
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.Recall(thresholds=0)])

[源代码]

`TruePositives` 类

keras.metrics.TruePositives(thresholds=None, name=None, dtype=None)

计算真阳性的数量。

如果给定了 sample_weight，则计算真阳性的权重之和。此指标创建一个局部变量 true_positives，用于跟踪真阳性的数量。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

参数

thresholds: (可选) 默认为 0.5。一个浮点数值，或一个 Python 浮点数值列表/元组，取值范围为 [0, 1]。阈值与预测值进行比较，以确定预测的真值（即，高于阈值为 True，低于阈值为 False）。如果与设置了 from_logits=True（即，未对预测应用 sigmoid 函数）的损失函数一起使用，则 thresholds 应设置为 0。为每个阈值生成一个指标值。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.TruePositives()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
>>> m.result()
2.0

>>> m.reset_state()
>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

[源代码]

`TrueNegatives` 类

keras.metrics.TrueNegatives(thresholds=None, name=None, dtype=None)

计算真阴性的数量。

如果给定了 sample_weight，则计算真阴性的权重之和。此指标创建一个局部变量 accumulator，用于跟踪真阴性的数量。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

参数

thresholds: (可选) 默认为 0.5。一个浮点数值，或一个 Python 浮点数值列表/元组，取值范围为 [0, 1]。阈值与预测值进行比较，以确定预测的真值（即，高于阈值为 True，低于阈值为 False）。如果与设置了 from_logits=True（即，未对预测应用 sigmoid 函数）的损失函数一起使用，则 thresholds 应设置为 0。为每个阈值生成一个指标值。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.TrueNegatives()
>>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0])
>>> m.result()
2.0

>>> m.reset_state()
>>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

[源代码]

`FalsePositives` 类

keras.metrics.FalsePositives(thresholds=None, name=None, dtype=None)

计算假阳性的数量。

如果给定了 sample_weight，则计算假阳性的权重之和。此指标创建一个局部变量 accumulator，用于跟踪假阳性的数量。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

参数

thresholds: (可选) 默认为 0.5。一个浮点数值，或一个 Python 浮点数值列表/元组，取值范围为 [0, 1]。阈值与预测值进行比较，以确定预测的真值（即，高于阈值为 True，低于阈值为 False）。如果与设置了 from_logits=True（即，未对预测应用 sigmoid 函数）的损失函数一起使用，则 thresholds 应设置为 0。为每个阈值生成一个指标值。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.FalsePositives()
>>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1])
>>> m.result()
2.0

>>> m.reset_state()
>>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

[源代码]

`FalseNegatives` 类

keras.metrics.FalseNegatives(thresholds=None, name=None, dtype=None)

计算假阴性的数量。

如果给定了 sample_weight，则计算假阴性的权重之和。此指标创建一个局部变量 accumulator，用于跟踪假阴性的数量。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

参数

thresholds: (可选) 默认为 0.5。一个浮点数值，或一个 Python 浮点数值列表/元组，取值范围为 [0, 1]。阈值与预测值进行比较，以确定预测的真值（即，高于阈值为 True，低于阈值为 False）。如果与设置了 from_logits=True（即，未对预测应用 sigmoid 函数）的损失函数一起使用，则 thresholds 应设置为 0。为每个阈值生成一个指标值。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.FalseNegatives()
>>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0])
>>> m.result()
2.0

>>> m.reset_state()
>>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0])
>>> m.result()
1.0

[源代码]

`PrecisionAtRecall` 类

keras.metrics.PrecisionAtRecall(
    recall, num_thresholds=200, class_id=None, name=None, dtype=None
)

计算召回率 >= 指定值时的最佳精确率。

此指标创建四个局部变量：true_positives、true_negatives、false_positives 和 false_negatives，用于计算给定召回率时的精确率。计算给定召回率值的阈值，并使用该阈值评估相应的精确率。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果指定了 class_id，我们仅考虑批次中 class_id 高于阈值预测的条目来计算精确率，并计算其中 class_id 确实是正确标签的条目的比例。

参数

recall: 一个标量值，范围为 [0, 1]。
num_thresholds: (可选) 默认为 200。用于匹配给定召回率的阈值数量。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.PrecisionAtRecall(0.5)
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
>>> m.result()
0.5

>>> m.reset_state()
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
...                sample_weight=[2, 2, 2, 1, 1])
>>> m.result()
0.33333333

与 compile() API 一起使用

model.compile(
    optimizer='sgd',
    loss='binary_crossentropy',
    metrics=[keras.metrics.PrecisionAtRecall(recall=0.8)])

[源代码]

`RecallAtPrecision` 类

keras.metrics.RecallAtPrecision(
    precision, num_thresholds=200, class_id=None, name=None, dtype=None
)

计算精确率 >= 指定值时的最佳召回率。

对于给定的分数-标签分布，可能无法达到所需的精确率，在这种情况下，返回的召回率为 0.0。

此指标创建四个局部变量：true_positives、true_negatives、false_positives 和 false_negatives，用于计算给定精确率时的召回率。计算给定精确率值的阈值，并使用该阈值评估相应的召回率。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果指定了 class_id，我们仅考虑批次中 class_id 高于阈值预测的条目来计算精确率，并计算其中 class_id 确实是正确标签的条目的比例。

参数

precision: 一个标量值，范围为 [0, 1]。
num_thresholds: (可选) 默认为 200。用于匹配给定精确率的阈值数量。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.RecallAtPrecision(0.8)
>>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9])
>>> m.result()
0.5

>>> m.reset_state()
>>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9],
...                sample_weight=[1, 0, 0, 1])
>>> m.result()
1.0

与 compile() API 一起使用

model.compile(
    optimizer='sgd',
    loss='binary_crossentropy',
    metrics=[keras.metrics.RecallAtPrecision(precision=0.8)])

[源代码]

`SensitivityAtSpecificity` 类

keras.metrics.SensitivityAtSpecificity(
    specificity, num_thresholds=200, class_id=None, name=None, dtype=None
)

计算特异度 >= 指定值时的最佳灵敏度。

Sensitivity 衡量实际阳性被正确识别为阳性的比例 (tp / (tp + fn))。Specificity 衡量实际阴性被正确识别为阴性的比例 (tn / (tn + fp))。

此指标创建四个局部变量：true_positives、true_negatives、false_positives 和 false_negatives，用于计算给定特异度时的灵敏度。计算给定特异度值的阈值，并使用该阈值评估相应的灵敏度。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果指定了 class_id，我们仅考虑批次中 class_id 高于阈值预测的条目来计算精确率，并计算其中 class_id 确实是正确标签的条目的比例。

有关特异度和灵敏度的更多信息，请参阅以下链接。

参数

specificity: 一个标量值，范围为 [0, 1]。
num_thresholds: (可选) 默认为 200。用于匹配给定特异度的阈值数量。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.SensitivityAtSpecificity(0.5)
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
>>> m.result()
0.5

>>> m.reset_state()
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
...                sample_weight=[1, 1, 2, 2, 1])
>>> m.result()
0.333333

与 compile() API 一起使用

model.compile(
    optimizer='sgd',
    loss='binary_crossentropy',
    metrics=[keras.metrics.SensitivityAtSpecificity()])

[源代码]

`SpecificityAtSensitivity` 类

keras.metrics.SpecificityAtSensitivity(
    sensitivity, num_thresholds=200, class_id=None, name=None, dtype=None
)

计算灵敏度 >= 指定值时的最佳特异度。

Sensitivity 衡量实际阳性被正确识别为阳性的比例 (tp / (tp + fn))。Specificity 衡量实际阴性被正确识别为阴性的比例 (tn / (tn + fp))。

此指标创建四个局部变量：true_positives、true_negatives、false_positives 和 false_negatives，用于计算给定灵敏度时的特异度。计算给定灵敏度值的阈值，并使用该阈值评估相应的特异度。

如果 sample_weight 为 None，则权重默认为 1。使用 sample_weight 为 0 来屏蔽值。

如果指定了 class_id，我们仅考虑批次中 class_id 高于阈值预测的条目来计算精确率，并计算其中 class_id 确实是正确标签的条目的比例。

有关特异度和灵敏度的更多信息，请参阅以下链接。

参数

sensitivity: 一个标量值，范围为 [0, 1]。
num_thresholds: (可选) 默认为 200。用于匹配给定灵敏度的阈值数量。
class_id：（可选）我们想要二元指标的整数类 ID。这必须在半开区间 [0, num_classes) 中，其中 num_classes 是预测的最后一个维度。
name：（可选）指标实例的字符串名称。
dtype：（可选）指标结果的数据类型。

示例

>>> m = keras.metrics.SpecificityAtSensitivity(0.5)
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
>>> m.result()
0.66666667

>>> m.reset_state()
>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
...                sample_weight=[1, 1, 2, 2, 2])
>>> m.result()
0.5

与 compile() API 一起使用

model.compile(
    optimizer='sgd',
    loss='binary_crossentropy',
    metrics=[keras.metrics.SpecificityAtSensitivity()])

[源代码]

`F1Score` 类

keras.metrics.F1Score(average=None, threshold=None, name="f1_score", dtype=None)

计算 F-1 分数。

公式

f1_score = 2 * (precision * recall) / (precision + recall)

这是精确率和召回率的调和平均值。其输出范围为 [0, 1]。它适用于多类和多标签分类。

参数

average: 要对数据执行的平均类型。可接受的值为 None、"micro"、"macro" 和 "weighted"。默认为 None。如果为 None，则不执行平均，并且 result() 将返回每个类的分数。如果为 "micro"，则通过计算总真阳性、假阴性和假阳性来全局计算指标。如果为 "macro"，则计算每个标签的指标，并返回它们的未加权平均值。这不考虑标签不平衡。如果为 "weighted"，则计算每个标签的指标，并返回它们的平均值，该平均值按支持度（每个标签的真实实例数）加权。这会改变 "macro" 以考虑标签不平衡。这可能会导致分数不在精确率和召回率之间。
threshold: 大于 threshold 的 y_pred 元素将转换为 1，其余转换为 0。如果 threshold 为 None，则将 y_pred 的 argmax 转换为 1，其余转换为 0。
name: 可选。指标实例的字符串名称。
dtype: 可选。指标结果的数据类型。

F-1 分数: 浮点数。

示例

>>> metric = keras.metrics.F1Score(threshold=0.5)
>>> y_true = np.array([[1, 1, 1],
...                    [1, 0, 0],
...                    [1, 1, 0]], np.int32)
>>> y_pred = np.array([[0.2, 0.6, 0.7],
...                    [0.2, 0.6, 0.6],
...                    [0.6, 0.8, 0.0]], np.float32)
>>> metric.update_state(y_true, y_pred)
>>> result = metric.result()
array([0.5      , 0.8      , 0.6666667], dtype=float32)

[源代码]

`FBetaScore` 类

keras.metrics.FBetaScore(
    average=None, beta=1.0, threshold=None, name="fbeta_score", dtype=None
)

计算 F-Beta 分数。

公式

b2 = beta ** 2
f_beta_score = (1 + b2) * (precision * recall) / (precision * b2 + recall)

这是精确率和召回率的加权调和平均值。其输出范围为 [0, 1]。它适用于多类和多标签分类。

参数

average: 在多类情况下对每个类别的结果执行平均的类型。可接受的值为 None、"micro"、"macro" 和 "weighted"。默认为 None。如果为 None，则不执行平均，并且 result() 将返回每个类的分数。如果为 "micro"，则通过计算总真阳性、假阴性和假阳性来全局计算指标。如果为 "macro"，则计算每个标签的指标，并返回它们的未加权平均值。这不考虑标签不平衡。如果为 "weighted"，则计算每个标签的指标，并返回它们的平均值，该平均值按支持度（每个标签的真实实例数）加权。这会改变 "macro" 以考虑标签不平衡。这可能会导致分数不在精确率和召回率之间。
beta: 确定在精确率和召回率之间的调和平均值中赋予召回率的权重（参见上面的伪代码公式）。默认为 1。
threshold: 大于 threshold 的 y_pred 元素将转换为 1，其余转换为 0。如果 threshold 为 None，则将 y_pred 的 argmax 转换为 1，其余转换为 0。
name: 可选。指标实例的字符串名称。
dtype: 可选。指标结果的数据类型。

F-Beta 分数: 浮点数。

示例

>>> metric = keras.metrics.FBetaScore(beta=2.0, threshold=0.5)
>>> y_true = np.array([[1, 1, 1],
...                    [1, 0, 0],
...                    [1, 1, 0]], np.int32)
>>> y_pred = np.array([[0.2, 0.6, 0.7],
...                    [0.2, 0.6, 0.6],
...                    [0.6, 0.8, 0.0]], np.float32)
>>> metric.update_state(y_true, y_pred)
>>> result = metric.result()
>>> result
[0.3846154 , 0.90909094, 0.8333334 ]

基于真/假阳性和阴性的分类指标

AUC 类

Precision 类

Recall 类

TruePositives 类

TrueNegatives 类

FalsePositives 类

FalseNegatives 类

PrecisionAtRecall 类

RecallAtPrecision 类

SensitivityAtSpecificity 类

SpecificityAtSensitivity 类

F1Score 类

FBetaScore 类

基于真/假阳性和阴性的分类指标

AUC 类

Precision 类

Recall 类

TruePositives 类

TrueNegatives 类

FalsePositives 类

FalseNegatives 类

PrecisionAtRecall 类

RecallAtPrecision 类

SensitivityAtSpecificity 类

SpecificityAtSensitivity 类

F1Score 类

FBetaScore 类

`AUC` 类

`Precision` 类

`Recall` 类

`TruePositives` 类

`TrueNegatives` 类

`FalsePositives` 类

`FalseNegatives` 类

`PrecisionAtRecall` 类

`RecallAtPrecision` 类

`SensitivityAtSpecificity` 类

`SpecificityAtSensitivity` 类

`F1Score` 类

`FBetaScore` 类