基于True/False正类和负类的分类指标

[source]

AUC class

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（曲线下面积）.

AUC（曲线下面积）是ROC（受试者工作特征;默认）或PR（精确召回）曲线的质量度量,用于二分类器.与准确性不同,并且类似于交叉熵损失,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 for details）;'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 logits.根据经验,当使用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])
>>> # 阈值值为[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:

# 报告输出概率模型的AUC.
model.compile(optimizer='sgd',
              loss=keras.losses.BinaryCrossentropy(),
              metrics=[keras.metrics.AUC()])

# 报告输出logit模型的AUC.
model.compile(optimizer='sgd',
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.AUC(from_logits=True)])

[source]

Precision class

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,我们将计算精确度为在批次条目中最高预测值的前 k 个类别中,平均有多少类别是正确的并且在对应条目的标签中可以找到.

如果指定了 class_id,我们将通过仅考虑批次中 class_id 高于阈值和/或在最高预测值的前 k 个类别中的条目,并计算其中 class_id 确实是正确标签的比例来计算精确度.

参数: 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.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

>>> # 使用 top_k=2,它将计算 y_true[:2] 和 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

>>> # 使用 top_k=4,它将计算 y_true[:4] 和 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)])

[source]

Recall class

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: (可选) 默认未设置.一个 int 值,指定计算召回率时要考虑的 top-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)])

[source]

TruePositives class

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

计算真阳性的数量.

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

如果 sample_weight 为 None,权重默认为 1.使用 sample_weight 为 0 来屏蔽值.

参数: thresholds: (可选) 默认为 0.5.一个浮点值,或一个在 [0, 1] 范围内的浮点阈值值的 Python 列表/元组.阈值用于与预测值进行比较,以确定预测的真值（即,高于阈值为 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

[source]

TrueNegatives class

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

计算真负数的数量.

如果给定 sample_weight,则计算真负数的权重之和.该指标创建一个局部变量 accumulator,用于跟踪真负数的数量.

如果 sample_weight 为 None,权重默认为 1.使用 sample_weight 为 0 来屏蔽值.

参数: thresholds: (可选) 默认为 0.5.一个浮点值,或一个在 [0, 1] 范围内的浮点阈值值的 Python 列表/元组.阈值用于与预测值进行比较,以确定预测的真值（即,高于阈值为 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

[source]

FalsePositives class

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

计算假阳性的数量.

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

如果 sample_weight 为 None,权重默认为 1.使用 sample_weight 为 0 来屏蔽值.

参数: thresholds: (可选) 默认为 0.5.一个浮点值,或一个在 [0, 1] 范围内的浮点阈值值的 Python 列表/元组.阈值用于与预测值进行比较,以确定预测的真值（即,高于阈值为 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

[source]

FalseNegatives class

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

[source]

PrecisionAtRecall class

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)])

[source]

RecallAtPrecision class

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)])

[source]

SensitivityAtSpecificity class

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

计算在特异性大于等于指定值时的最佳敏感度.

敏感度 衡量实际阳性中被正确识别为阳性的比例 (tp / (tp + fn)). 特异性 衡量实际阴性中被正确识别为阴性的比例 (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()])

[source]

SpecificityAtSensitivity class

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

计算在灵敏度大于等于指定值时的最佳特异性.

灵敏度 衡量实际阳性中被正确识别为阳性的比例 (tp / (tp + fn)). 特异性 衡量实际阴性中被正确识别为阴性的比例 (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()])

[source]

F1Score class

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: y_pred中大于threshold的元素被转换为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)

[source]

FBetaScore class

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: y_pred 中大于 threshold 的元素被转换为 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 ]