图像分割指标
IoU class
keras.metrics.IoU(
num_classes,
target_class_ids,
name=None,
dtype=None,
ignore_class=None,
sparse_y_true=True,
sparse_y_pred=True,
axis=-1,
)
计算特定目标类别的交并比（Intersection-Over-Union, IoU）指标.
公式:
iou = true_positives / (true_positives + false_positives + false_negatives)
交并比是语义图像分割中常用的评估指标.
为了计算IoU,预测结果会累积到一个混淆矩阵中,并根据sample_weight进行加权,然后从中计算该指标.
如果sample_weight为None,权重默认为1.
使用sample_weight为0来屏蔽值.
注意,此类首先计算所有单独类别的IoU,然后返回由target_class_ids指定的类别的IoU的平均值.如果target_class_ids只有一个id值,则返回该特定类别的IoU.
参数:
num_classes: 预测任务可能拥有的标签数量.
target_class_ids: 一个元组或列表,包含要返回指标的目标类别id.要计算特定类别的IoU,应提供一个包含单个id值的列表（或元组）.
name: （可选）指标实例的字符串名称.
dtype: （可选）指标结果的数据类型.
ignore_class: 可选整数.在计算指标时要忽略的类别ID.这在分割问题中很有用,例如在分割图中有一个"void”类别（通常为-1或255）.默认情况下（ignore_class=None）,所有类别都会被考虑.
sparse_y_true: 标签是否使用整数或密集浮点向量进行编码.如果为False,则使用argmax函数来确定每个样本最可能关联的标签.
sparse_y_pred: 预测是否使用整数或密集浮点向量进行编码.如果为False,则使用argmax函数来确定每个样本最可能关联的标签.
axis: （可选）-1是包含logits的维度.默认为-1.
示例:
>>> # cm = [[1, 1],
>>> # [1, 1]]
>>> # sum_row = [2, 2], sum_col = [2, 2], true_positives = [1, 1]
>>> # iou = true_positives / (sum_row + sum_col - true_positives))
>>> # iou = [0.33, 0.33]
>>> m = keras.metrics.IoU(num_classes=2, target_class_ids=[0])
>>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1])
>>> m.result()
0.33333334
>>> m.reset_state()
>>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1],
... sample_weight=[0.3, 0.3, 0.3, 0.1])
>>> # cm = [[0.3, 0.3],
>>> # [0.3, 0.1]]
>>> # sum_row = [0.6, 0.4], sum_col = [0.6, 0.4],
>>> # true_positives = [0.3, 0.1]
>>> # iou = [0.33, 0.14]
>>> m.result()
0.33333334
与compile() API一起使用:
model.compile(
optimizer='sgd',
loss='mse',
metrics=[keras.metrics.IoU(num_classes=2, target_class_ids=[0])])
BinaryIoU class
keras.metrics.BinaryIoU(
target_class_ids=(0, 1), threshold=0.5, name=None, dtype=None
)
计算类别0和/或1的交并比（Intersection-Over-Union）指标.
公式:
iou = true_positives / (true_positives + false_positives + false_negatives)
交并比是语义图像分割中常用的评估指标.
为了计算交并比,预测结果被累积在一个混淆矩阵中,并根据sample_weight进行加权,然后从该矩阵中计算该指标.
如果sample_weight为None,权重默认为1.
使用sample_weight为0来屏蔽值.
该类可用于计算二分类任务的交并比,其中预测结果以logits形式提供.首先应用一个threshold,将低于threshold的预测值转换为类别0,高于threshold的预测值转换为类别1.
然后计算类别0和1的交并比,返回由target_class_ids指定的类别的交并比的平均值.
注意:当threshold=0时,该指标的行为与IoU相同.
参数:
target_class_ids: 一个目标类别id的元组或列表,为其返回指标.选项为[0]、[1]或[0, 1].使用[0]（或[1]）,返回类别0（或类别1）的交并比指标.使用[0, 1],返回两个类别的交并比的平均值.
threshold: 应用于预测logits的阈值,将低于threshold的logits转换为预测类别0,高于threshold的logits转换为预测类别1.
name: （可选）指标实例的字符串名称.
dtype: （可选）指标结果的数据类型.
示例:
示例:
>>> m = keras.metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.3)
>>> m.update_state([0, 1, 0, 1], [0.1, 0.2, 0.4, 0.7])
>>> m.result()
0.33333334
>>> m.reset_state()
>>> m.update_state([0, 1, 0, 1], [0.1, 0.2, 0.4, 0.7],
... sample_weight=[0.2, 0.3, 0.4, 0.1])
>>> # cm = [[0.2, 0.4],
>>> # [0.3, 0.1]]
>>> # sum_row = [0.6, 0.4], sum_col = [0.5, 0.5],
>>> # true_positives = [0.2, 0.1]
>>> # iou = [0.222, 0.125]
>>> m.result()
0.17361112
与compile() API一起使用:
model.compile(
optimizer='sgd',
loss='mse',
metrics=[keras.metrics.BinaryIoU(
target_class_ids=[0],
threshold=0.5
)]
)
OneHotIoU class
keras.metrics.OneHotIoU(
num_classes,
target_class_ids,
name=None,
dtype=None,
ignore_class=None,
sparse_y_pred=False,
axis=-1,
)
计算one-hot编码标签的Intersection-Over-Union指标.
公式:
iou = true_positives / (true_positives + false_positives + false_negatives)
Intersection-Over-Union是语义图像分割中常用的评估指标.
为了计算IoU,预测结果会累积在一个混淆矩阵中,并根据sample_weight进行加权,然后从中计算该指标.
如果sample_weight为None,权重默认为1.
使用sample_weight为0来屏蔽值.
该类可用于计算多类分类任务的IoU,其中标签是one-hot编码的（最后一个轴应有每个类的一个维度）.请注意,预测结果也应具有相同的形状.为了计算IoU,首先将标签和预测结果通过在类别轴上取argmax转换回整数格式.然后,与基础IoU类的相同计算步骤适用.
注意,如果标签和预测结果中只有一个通道,该类与IoU类相同.在这种情况下,请使用IoU.
此外,确保num_classes等于数据中的类别数量,以避免在计算混淆矩阵时出现"标签越界”错误.
参数:
num_classes: 预测任务可能拥有的标签数量.
target_class_ids: 一个元组或目标类ID列表,用于返回指标.要计算特定类的IoU,应提供一个单个ID值的列表（或元组）.
name: （可选）指标实例的字符串名称.
dtype: （可选）指标结果的数据类型.
ignore_class: 可选整数.在计算指标时要忽略的类的ID.这在分割问题中很有用,例如在分割图中有一个"void”类（通常为-1或255）.默认情况下（ignore_class=None）,所有类别都会被考虑.
sparse_y_pred: 预测结果是否使用整数编码或密集浮点向量.如果为False,则使用argmax函数来确定每个样本最可能关联的标签.
axis: （可选）包含logits的维度.默认为-1.
示例:
示例:
>>> y_true = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
>>> y_pred = np.array([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1],
... [0.1, 0.4, 0.5]])
>>> sample_weight = [0.1, 0.2, 0.3, 0.4]
>>> m = keras.metrics.OneHotIoU(num_classes=3, target_class_ids=[0, 2])
>>> m.update_state(
... y_true=y_true, y_pred=y_pred, sample_weight=sample_weight)
>>> # cm = [[0, 0, 0.2+0.4],
>>> # [0.3, 0, 0],
>>> # [0, 0, 0.1]]
>>> # sum_row = [0.3, 0, 0.7], sum_col = [0.6, 0.3, 0.1]
>>> # true_positives = [0, 0, 0.1]
>>> # single_iou = true_positives / (sum_row + sum_col - true_positives))
>>> # mean_iou = (0 / (0.3 + 0.6 - 0) + 0.1 / (0.7 + 0.1 - 0.1)) / 2
>>> m.result()
0.071
使用compile() API的示例:
model.compile(
optimizer='sgd',
loss='mse',
metrics=[keras.metrics.OneHotIoU(
num_classes=3,
target_class_id=[1]
)]
)
OneHotMeanIoU class
keras.metrics.OneHotMeanIoU(
num_classes, name=None, dtype=None, ignore_class=None, sparse_y_pred=False, axis=-1
)
计算one-hot编码标签的平均交并比（Intersection-Over-Union, IoU）指标.
公式:
iou = true_positives / (true_positives + false_positives + false_negatives)
交并比是语义图像分割中常用的评估指标.
为了计算IoU,预测结果会累积在一个混淆矩阵中,并根据sample_weight进行加权,然后从中计算该指标.
如果sample_weight为None,权重默认为1.
使用sample_weight为0来屏蔽值.
该类可用于计算多类分类任务的平均IoU,其中标签是one-hot编码的（最后一个轴应有每个类的一个维度）.请注意,预测结果也应具有相同的形状.为了计算平均IoU,首先将标签和预测结果通过在类别轴上取argmax转换回整数格式.然后,应用与基础MeanIoU类相同的计算步骤.
注意,如果标签和预测结果中只有一个通道,该类与MeanIoU类相同.在这种情况下,请使用MeanIoU.
此外,确保num_classes等于数据中的类别数,以避免在计算混淆矩阵时出现"标签越界”错误.
参数:
num_classes: 预测任务可能具有的标签数量.
name: （可选）指标实例的字符串名称.
dtype: （可选）指标结果的数据类型.
ignore_class: 可选整数.在计算指标时要忽略的类的ID.这在分割问题中很有用,例如在分割图中有一个"void”类（通常为-1或255）.默认情况下（ignore_class=None）,所有类别都会被考虑.
sparse_y_pred: 预测结果是否使用自然数编码或概率分布向量.如果为False,将使用argmax函数来确定每个样本最可能关联的标签.
axis: （可选）包含logits的维度.默认为-1.
示例:
>>> y_true = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
>>> y_pred = np.array([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1],
... [0.1, 0.4, 0.5]])
>>> sample_weight = [0.1, 0.2, 0.3, 0.4]
>>> m = keras.metrics.OneHotMeanIoU(num_classes=3)
>>> m.update_state(
... y_true=y_true, y_pred=y_pred, sample_weight=sample_weight)
>>> # cm = [[0, 0, 0.2+0.4],
>>> # [0.3, 0, 0],
>>> # [0, 0, 0.1]]
>>> # sum_row = [0.3, 0, 0.7], sum_col = [0.6, 0.3, 0.1]
>>> # true_positives = [0, 0, 0.1]
>>> # single_iou = true_positives / (sum_row + sum_col - true_positives))
>>> # mean_iou = (0 + 0 + 0.1 / (0.7 + 0.1 - 0.1)) / 3
>>> m.result()
0.048
使用compile() API的示例:
model.compile(
optimizer='sgd',
loss='mse',
metrics=[keras.metrics.OneHotMeanIoU(num_classes=3)])
MeanIoU class
keras.metrics.MeanIoU(
num_classes,
name=None,
dtype=None,
ignore_class=None,
sparse_y_true=True,
sparse_y_pred=True,
axis=-1,
)
计算平均交并比（Intersection-Over-Union）指标.
公式:
iou = true_positives / (true_positives + false_positives + false_negatives)
交并比是语义图像分割中常用的评估指标.
为了计算交并比,预测结果会累积在一个混淆矩阵中,并根据 sample_weight 进行加权,然后从该矩阵中计算指标.
如果 sample_weight 为 None,权重默认为 1.
使用 sample_weight 为 0 来屏蔽值.
注意,这个类首先计算所有单独类别的交并比,然后返回这些值的平均值.
参数:
num_classes: 预测任务可能拥有的标签数量.
这个值必须提供,因为将分配一个维度为 [num_classes, num_classes] 的混淆矩阵.
name: （可选）指标实例的字符串名称.
dtype: （可选）指标结果的数据类型.
ignore_class: 可选整数.在计算指标时要忽略的类的 ID.这在分割问题中很有用,例如在分割图中有一个"void”类（通常为 -1 或 255）.默认情况下（ignore_class=None）,所有类别都会被考虑.
sparse_y_true: 标签是否使用整数或密集浮点向量进行编码.如果为 False,则使用 argmax 函数来确定每个样本最可能关联的标签.
sparse_y_pred: 预测是否使用整数或密集浮点向量进行编码.如果为 False,则使用 argmax 函数来确定每个样本最可能关联的标签.
axis: （可选）包含逻辑值的维度.默认为 -1.
示例:
>>> # cm = [[1, 1],
>>> # [1, 1]]
>>> # sum_row = [2, 2], sum_col = [2, 2], true_positives = [1, 1]
>>> # iou = true_positives / (sum_row + sum_col - true_positives))
>>> # result = (1 / (2 + 2 - 1) + 1 / (2 + 2 - 1)) / 2 = 0.33
>>> m = keras.metrics.MeanIoU(num_classes=2)
>>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1])
>>> m.result()
0.33333334
>>> m.reset_state()
>>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1],
... sample_weight=[0.3, 0.3, 0.3, 0.1])
>>> m.result().numpy()
0.23809525
使用 compile() API 的示例:
model.compile(
optimizer='sgd',
loss='mse',
metrics=[keras.metrics.MeanIoU(num_classes=2)])