指标#

FROC#

monai.metrics.compute_fp_tp_probs(probs, y_coord, x_coord, evaluation_mask, labels_to_exclude=None, resolution_level=0)[源代码]#

此函数修改自 CAMELYON 16 Challenge 的官方评估代码，用于区分真阳性和假阳性预测。当检测点位于标注的地面真实区域内时，被定义为真阳性预测。

参数:

  • probs – 形状为 (n,) 的数组，表示检测的概率。其中，n 是预测检测的数量。

  • y_coord – 形状为 (n,) 的数组，表示检测的 Y 坐标。

  • x_coord – 形状为 (n,) 的数组，表示检测的 X 坐标。

  • evaluation_mask – 用于评估的地面真实掩膜。

  • labels_to_exclude – 此列表中的标签将不计入指标计算。

  • resolution_level – 构建 evaluation mask 的级别。

返回:

包含假阳性检测概率的数组。tp_probs: 包含真阳性检测概率的数组。num_targets: 所有待评估图像的总目标数量（不包括 labels_to_exclude）。

返回类型:

fp_probs

monai.metrics.compute_froc_curve_data(fp_probs, tp_probs, num_targets, num_images)[源代码]#

此函数修改自 CAMELYON 16 Challenge 的官方评估代码，用于计算绘制自由响应工作特性 (Free Response Operating Characteristic, FROC) 曲线所需的数据。

参数:

  • fp_probs – 包含所有待评估图像的假阳性检测概率的数组。

  • tp_probs – 包含所有待评估图像的真阳性检测概率的数组。

  • num_targets – 所有待评估图像的总目标数量（不包括 labels_to_exclude）。

  • num_images – 待评估图像的数量。

monai.metrics.compute_froc_score(fps_per_image, total_sensitivity, eval_thresholds=(0.25, 0.5, 1, 2, 4, 8))[源代码]#

此函数修改自 CAMELYON 16 Challenge 的官方评估代码，用于计算挑战的第二个评估指标，该指标定义为在预定义的每张全玻片图像的假阳性率下的平均敏感度。

参数:

  • fps_per_image (ndarray) – 不同阈值下每张图像的平均假阳性数。

  • total_sensitivity (ndarray) – 不同阈值下的敏感度（真阳性率）。

  • eval_thresholds (tuple) – 用于计算平均敏感度的假阳性率。默认为 (0.25, 0.5, 1, 2, 4, 8)，与 CAMELYON 16 Challenge 相同。

返回类型:

Any

Metric#

class monai.metrics.Metric[源代码]#

用于计算模型性能评估指标的基类。设计 __call__ 以执行计算。

Variance#

monai.metrics.compute_variance(y_pred, include_background=True, spatial_map=False, scalar_reduction='mean', threshold=0.0005)[源代码]#
参数:

  • y_pred – [N, C, H, W, D] 或 [N, C, H, W] 或 [N, C, H]，其中 N 是重复次数，C 是通道数，H, W, D 分别代表高度、宽度和深度

  • include_background – 是否包含空间图像的背景或一维向量的通道 0

  • spatial_map – 布尔值，如果设置为 True，将返回与输入图像维度对应的方差空间图

  • scalar_reduction – 指标的归约类型，可使用 ‘sum’ 或 ‘mean’

  • threshold – 为避免 NaN 值，使用阈值来替换零值

返回:

单个标量不确定性/方差值或不确定性/方差的空间图

class monai.metrics.VarianceMetric(include_background=True, spatial_map=False, scalar_reduction='sum', threshold=0.0005)[源代码]#

计算给定 T 次重复的 N 维数组/张量的方差。主要用途是作为主动学习中基于不确定性的指标。

它可以根据用户选择返回空间方差/不确定性图，或者通过方差的平均值/总和返回单个标量值用于评分目的

参数:

  • include_background (bool) – 是否包含空间图像的背景或一维向量的通道 0

  • spatial_map (bool) – 布尔值，如果设置为 True，将返回与输入图像维度对应的方差空间图

  • scalar_reduction (str) – 指标的归约类型，可使用 ‘sum’ 或 ‘mean’

  • threshold (float) – 为避免 NaN 值，使用阈值来替换零值

LabelQualityScore#

monai.metrics.label_quality_score(y_pred, y, include_background=True, scalar_reduction='mean')[源代码]#

假设 DL 模型比提供的标签质量有更好的预测，因此差异可以被视为标签质量分数

参数:

  • y_pred – 输入数据，维度为 [B, C, H, W, D] 或 [B, C, H, W] 或 [B, C, H]，其中 B 是批处理大小，C 是通道数，H, W, D 分别代表高度、宽度和深度

  • y – 地面真实数据，维度为 [B, C, H, W, D] 或 [B, C, H, W] 或 [B, C, H]，其中 B 是批处理大小，C 是通道数，H, W, D 分别代表高度、宽度和深度

  • include_background – 是否包含空间图像的背景或一维向量的通道 0

  • scalar_reduction – 指标的归约类型，可使用 ‘sum’ 或 ‘mean’ 来获取单个标量值，如果设置为 ‘none’，则返回空间图

返回:

单个标量绝对差值作为分数，根据 sum/mean 进行归约，或者绝对差值的空间图

class monai.metrics.LabelQualityScore(include_background=True, scalar_reduction='sum')[源代码]#

假设 DL 模型比提供的标签质量有更好的预测，因此差异可以被视为标签质量分数

它可以与方差/不确定性结合用于主动学习框架，以将标签质量和不确定性考虑在内 :type include_background: bool :param include_background: 是否包含空间图像的背景或一维向量的通道 0 :param spatial_map: 布尔值，如果设置为 True，将返回与输入图像维度对应的方差空间图 :param dimensions: :type scalar_reduction: str :param scalar_reduction: 指标的归约类型，可使用 ‘sum’ 或 ‘mean’

IterationMetric#

class monai.metrics.IterationMetric[源代码]#

用于在迭代级别计算指标的基类，即在样本的 mini-batch 上进行计算，通常使用一次迭代的模型输出。

__call__ 设计用于处理 PyTorch 张量或张量列表/元组中的 y_pred 和 y（可选）。

子类通常实现 _compute_tensor 函数以处理实际的张量计算逻辑。

Cumulative#

class monai.metrics.Cumulative[源代码]#

基于 PyTorch 张量的典型累积计算过程的实用工具类。它提供接口以在本地缓冲区中累积值，在分布式节点间同步缓冲区，并聚合缓冲值。

在多进程中，PyTorch 程序通常将数据分发到多个节点。每个节点使用数据的一个子集运行，并将值添加到其本地缓冲区。调用 get_buffer 可以收集所有结果，而 aggregate 可以进一步处理结果以生成最终输出。

用户可以实现自己的 aggregate 方法来处理结果，使用 get_buffer 获取缓冲内容。

注意: 在一轮中每次调用 add() 时，数据列表的长度应相同，它将根据数据列表的长度自动创建缓冲区。

通常，此类别预计会执行以下步骤

from monai.metrics import Cumulative

c = Cumulative()
c.append(1)  # adds a value
c.extend([2, 3])  # adds a batch of values
c.extend([4, 5, 6])  # adds a batch of values
print(c.get_buffer())  # tensor([1, 2, 3, 4, 5, 6])
print(len(c))  # 6
c.reset()
print(len(c))  # 0

以下是维护两个内部缓冲区的示例

from monai.metrics import Cumulative

c = Cumulative()
c.append(1, 2)  # adds a value to two buffers respectively
c.extend([3, 4], [5, 6])  # adds batches of values
print(c.get_buffer())  # [tensor([1, 3, 4]), tensor([2, 5, 6])]
print(len(c))

以下是扩展可变长度数据的示例

import torch
from monai.metrics import Cumulative

c = Cumulative()
c.extend(torch.zeros((8, 2)), torch.zeros((6, 2)))  # adds batches
c.append(torch.zeros((2, )))  # adds a value
print(c.get_buffer())  # [torch.zeros((9, 2)), torch.zeros((6, 2))]
print(len(c))
__init__()[源代码]#

初始化内部缓冲区。self._buffers 是本地缓冲区，通常不直接使用。self._sync_buffers 是跨所有节点的所有结果的缓冲区。

abstract aggregate(*args, **kwargs)[源代码]#

根据收集的缓冲区聚合最终结果。此方法应使用 get_buffer 来收集本地缓冲区内容。

返回类型:

Any

append(*data)[源代码]#

将样本添加到本地累积缓冲区。将为每个 data 项分配一个缓冲区。与 self.extend 相比，此方法向本地缓冲区添加单个样本（而不是“批量”）。

参数:

data (Any) – 每个项将转换为 torch 张量。当调用 get_buffer() 时，它们将在第 0 维堆叠一个新的维度。

返回类型:

None

extend(*data)[源代码]#

使用新的（“批量优先”）数据扩展本地缓冲区。将为每个 data 项分配一个缓冲区。与 self.append 相比，此方法向本地缓冲区添加一批数据。

参数:

data (Any) – 每个项可以是“批量优先”张量或“通道优先”张量列表。当调用 get_buffer() 时，它们将在第 0 维度连接。

返回类型:

None

get_buffer()[源代码]#

获取同步的缓冲区列表。典型的用法是根据原始指标详细信息生成指标报告。每个缓冲区都是一个 PyTorch 张量。

reset()[源代码]#

重置累积张量和同步结果的缓冲区。

CumulativeIterationMetric#

class monai.metrics.CumulativeIterationMetric[源代码]#

累积指标的基类，它在迭代级别收集每个 mini-batch 数据的指标。

通常，它会为每次迭代计算一些中间结果，将它们添加到缓冲区，然后在 epoch 完成时收集并聚合缓冲区内容以获得最终结果。目前，预期实现 Cumulative.aggregate() 和 IterationMetric._compute_tensor()。

例如，MeanDice 继承此类，用法如下

dice_metric = DiceMetric(include_background=True, reduction="mean")

for val_data in val_loader:
    val_outputs = model(val_data["img"])
    val_outputs = [postprocessing_transform(i) for i in decollate_batch(val_outputs)]
    # compute metric for current iteration
    dice_metric(y_pred=val_outputs, y=val_data["seg"])  # callable to add metric to the buffer

# aggregate the final mean dice result
metric = dice_metric.aggregate().item()

# reset the status for next computation round
dice_metric.reset()

要从文件中加载 predictions 和 labels，然后使用多进程计算指标，请参考：Project-MONAI/tutorials。

LossMetric#

class monai.metrics.LossMetric(loss_fn, reduction=mean, get_not_nans=False)[源代码]#

一个包装器，将 loss_fn 作为一个累积指标提供。也就是说，从 mini-batch 计算的损失值可以在多次迭代中以 reduction 模式组合，作为模型的定量衡量。

示例

import torch
from monai.losses import DiceLoss
from monai.metrics import LossMetric

dice_loss = DiceLoss(include_background=True)
loss_metric = LossMetric(loss_fn=dice_loss)

# first iteration
y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
loss_metric(y_pred, y)

# second iteration
y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 0.0]]]])  # shape [batch=1, channel=1, 2, 2]
y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
loss_metric(y_pred, y)

# aggregate
print(loss_metric.aggregate(reduction="none"))  # tensor([[0.2000], [0.5000]]) (shape [batch=2, channel=1])

# reset
loss_metric.reset()
print(loss_metric.aggregate())
参数:

  • loss_fn – 一个可调用函数，以 y_pred 和可选的 y 作为输入（“批量优先”格式），返回一个“批量优先”的损失值张量。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

aggregate(reduction=None)[源代码]#

返回多次迭代聚合后的损失值。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Mean Dice#

class monai.metrics.DiceMetric(include_background=True, reduction=mean, get_not_nans=False, ignore_empty=True, num_classes=None, return_with_label=False)[源代码]#

计算一组预测-地面真实分割对的平均 Dice 分数。

它支持多类和多标签任务。输入 y_pred 与地面真实 y 进行比较。y_pred 预期是二值化预测，而 y 可以是单通道类别索引或 one-hot 格式。include_background 参数可以设置为 False 以排除按照惯例被假定为背景的第一个类别（通道索引 0）。如果非背景分割相对于总图像尺寸较小，它们可能会被背景的信号所压倒。y_preds 和 y 可以是通道优先张量 (CHW[D]) 的列表，或批量优先张量 (BCHW[D])，y 也可以是 B1HW[D] 格式。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 是否对预测输出的第一个通道进行 Dice 计算。默认为 True。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

  • ignore_empty – 计算时是否忽略空的地面真实情况。如果为 True，对于空的地面真实情况将设置为 NaN 值。如果为 False，如果空的地面真实情况的预测也为空，则将设置为 1。

  • num_classes – 输入通道数（始终包括背景）。当此参数为 None 时，将使用 y_pred.shape[1]。当 y_pred 和 y 都是单通道类别索引且类别数无法从数据中自动推断时，此选项很有用。

  • return_with_label – 是否返回带标签的指标，仅在 reduction 为“mean_batch”时有效。如果为 True，则使用“label_{index}”作为对应于 C 个通道的键；如果“include_background”为 True，则索引从“0”开始，否则从“1”开始。它也可以接受标签名称列表。结果将以字典形式返回。

aggregate(reduction=None)[源代码]#

对 compute_dice 的输出执行归约和聚合逻辑。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

class monai.metrics.DiceHelper(include_background=None, sigmoid=False, softmax=None, activate=False, get_not_nans=True, reduction=mean_batch, ignore_empty=True, num_classes=None)[源代码]#

计算两个张量 y_pred 和 y 之间的 Dice 分数。y_pred 和 y 可以是单通道类别索引或 one-hot 格式。

示例

import torch
from monai.metrics import DiceHelper

n_classes, batch_size = 5, 16
spatial_shape = (128, 128, 128)

y_pred = torch.rand(batch_size, n_classes, *spatial_shape).float()  # predictions
y = torch.randint(0, n_classes, size=(batch_size, 1, *spatial_shape)).long()  # ground truth

score, not_nans = DiceHelper(include_background=False, sigmoid=True, softmax=True)(y_pred, y)
print(score, not_nans)
__init__(include_background=None, sigmoid=False, softmax=None, activate=False, get_not_nans=True, reduction=mean_batch, ignore_empty=True, num_classes=None)[源代码]#
参数:

  • include_background – 是否包含第一个通道上的分数（默认为 sigmoid 的值，False）。

  • sigmoid – y_pred 是否是/将是 sigmoid 激活的输出。如果为 True，将执行 0.5 的阈值处理以获得离散预测。默认为 False。

  • softmax – y_pred 是否是 softmax 激活的输出。如果为 True，将执行 argmax 以获得离散预测。默认为 not sigmoid 的值。

  • activate – 如果 sigmoid 为 True，是否对 y_pred 应用 sigmoid。默认为 False。此选项仅在 sigmoid 为 True 时有效。

  • get_not_nans – 是否返回非 NaN 值的数量。

  • reduction – 定义指标的归约模式

  • ignore_empty – 如果为 True，对于空的地面真实情况将设置为 NaN 值。如果为 False，如果 y_pred 和 y 的并集为空，则将设置为 1。

  • num_classes – 输入通道数（始终包括背景）。当此参数为 None 时，将使用 y_pred.shape[1]。当 y_pred 和 y 都是单通道类别索引且类别数无法从数据中自动推断时，此选项很有用。

Mean IoU#

monai.metrics.compute_iou(y_pred, y, include_background=True, ignore_empty=True)[源代码]#

从一批预测中计算 Intersection over Union (IoU) 分数指标。

参数:

  • y_pred (Tensor) – 要计算的输入数据，典型的分割模型输出。它必须是 one-hot 格式，第一个维度是批量，示例形状：[16, 3, 32, 32]。值应为二值化。

  • y (Tensor) – 用于计算 Mean IoU 指标的地面真实。它必须是 one-hot 格式，第一个维度是批量。值应为二值化。

  • include_background (bool) – 是否对预测输出的第一个通道进行 IoU 计算。默认为 True。

  • ignore_empty (bool) – 计算时是否忽略空的地面真实情况。如果为 True，对于空的地面真实情况将设置为 NaN 值。如果为 False，如果空的地面真实情况的预测也为空，则将设置为 1。

返回类型:

Tensor

返回:

每批量和每类别的 IoU 分数（形状 [batch_size, num_classes]）。

抛出:

ValueError – 当 y_pred 和 y 形状不同时。

class monai.metrics.MeanIoU(include_background=True, reduction=mean, get_not_nans=False, ignore_empty=True)[源代码]#

计算两个张量之间的平均 Intersection over Union (IoU) 分数。它支持多类和多标签任务。输入 y_pred 与地面真实 y 进行比较。y_pred 预期是二值化预测，而 y 应该是 one-hot 格式。你可以先使用 monai.transforms.post 中的合适变换来实现二值化值。include_background 参数可以设置为 False 以排除按照惯例被假定为背景的第一个类别（通道索引 0）。如果非背景分割相对于总图像尺寸较小，它们可能会被背景的信号所压倒。y_pred 和 y 可以是通道优先张量 (CHW[D]) 的列表，或批量优先张量 (BCHW[D])。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 是否对预测输出的第一个通道进行 IoU 计算。默认为 True。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

  • ignore_empty – 计算时是否忽略空的地面真实情况。如果为 True，对于空的地面真实情况将设置为 NaN 值。如果为 False，如果空的地面真实情况的预测也为空，则将设置为 1。

aggregate(reduction=None)[源代码]#

对 compute_iou 的输出执行归约逻辑。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Generalized Dice Score#

monai.metrics.compute_generalized_dice(y_pred, y, include_background=True, weight_type=square, sum_over_classes=False)[源代码]#

计算广义 Dice 分数，并返回包含其每图像值的张量。

参数:

  • y_pred (torch.Tensor) – 二值化分割模型输出。它应该是二值化、one-hot 格式并处于 NCHW[D] 格式，其中 N 是批量维度，C 是通道维度，其余是空间维度。

  • y (torch.Tensor) – 二值化地面真实。它应该是二值化、one-hot 格式，并且与 y_pred 具有相同的形状。

  • include_background – 是否包含对预测输出的第一个通道进行分数计算。默认为 True。

  • weight_type (Union[Weight, str], optional) – {"square", "simple", "uniform"}。将地面真实体积转换为权重因子的函数类型。默认为 "square"。

  • sum_over_labels (bool) – 在最终计算之前，是否在所有标签上对分子和分母求和。

返回:

每批量和每类别的广义 Dice 分数，即形状为 [batch_size, num_classes]。

返回类型:

torch.Tensor

抛出:

ValueError – 如果 y_pred 或 y 不是 PyTorch 张量，如果 y_pred 和 y 的维度小于三，或者 y_pred 和 y 的形状不同。

class monai.metrics.GeneralizedDiceScore(include_background=True, reduction=mean_batch, weight_type=square)[源代码]#

计算张量之间的广义 Dice 分数指标。

此指标是 Sudre, C. 等人 (2017) Generalised Dice overlap as a deep learning loss function for highly unbalanced segmentations. DLMIA 2017 中定义的广义 Dice 损失的补充。

输入 y_pred 和 y 预期是 one-hot、二值化的批量优先张量，即 NCHW[D]。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 计算分数时是否包含背景类别（假定在通道 0 中）。默认为 True。

  • reduction – 定义指标的归约模式。可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • weight_type – {"square", "simple", "uniform"}。将地面真实体积转换为权重因子的函数类型。默认为 "square"。

抛出:

ValueError – 当 reduction 不是 MetricReduction 枚举之一时。

aggregate(reduction=None)[源代码]#

对 compute_generalized_dice 的输出执行归约逻辑。

返回:

聚合的指标值。

返回类型:

torch.Tensor

抛出:

ValueError – 如果要聚合的数据不是 PyTorch 张量。

Area under the ROC curve#

monai.metrics.compute_roc_auc(y_pred, y, average=macro)[源代码]#

计算接收者操作特征曲线下面积 (ROC AUC)。参考：sklearn.metrics.roc_auc_score。

参数:

  • y_pred – 要计算的输入数据，典型的分类模型输出。第一个维度必须是批量，如果是多类，必须是 One-Hot 格式。例如：二进制数据的形状为 [16] 或 [16, 1]，2 类数据的形状为 [16, 2]。

  • y – 用于计算 ROC AUC 指标的地面真实，第一个维度必须是批量。如果是多类，必须是 One-Hot 格式。例如：二进制数据的形状为 [16] 或 [16, 1]，2 类数据的形状为 [16, 2]。

  • average –

    {"macro", "weighted", "micro", "none"} 如果不是二分类，执行的平均类型。默认为 "macro"。

    • "macro": 计算每个标签的指标，并找到它们的未加权平均值。

      这不考虑标签不平衡。

    • "weighted": 计算每个标签的指标，并找到它们的平均值，

      按支持度（每个标签的真实实例数量）加权。

    • "micro": 通过将标签指标矩阵的每个元素视为一个标签来全局计算指标。

      将指示矩阵作为标签。

    • "none": 返回每个类别的分数。

抛出:

  • ValueError – 当 y_pred 维度不是 [1, 2] 之一时。

  • ValueError – 当 y 维度不是 [1, 2] 之一时。

  • ValueError – 当 average 不是 ["macro", "weighted", "micro", "none"] 之一时。

注意

ROCAUC 期望 y 由 0 和 1 组成。y_pred 必须是概率估计或置信度值。

class monai.metrics.ROCAUCMetric(average=macro)[源代码]#

计算接收者操作特征曲线下面积 (ROC AUC)。参考：sklearn.metrics.roc_auc_score。输入 y_pred 和 y 可以是 channel-first 张量列表或 batch-first 张量。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

average –

{"macro", "weighted", "micro", "none"} 如果不是二分类，执行的平均类型。默认为 "macro"。

  • "macro": 计算每个标签的指标，并找到它们的未加权平均值。

    这不考虑标签不平衡。

  • "weighted": 计算每个标签的指标，并找到它们的平均值，

    按支持度（每个标签的真实实例数量）加权。

  • "micro": 通过将标签指标矩阵的每个元素视为一个标签来全局计算指标。

    将指示矩阵作为标签。

  • "none": 返回每个类别的分数。

aggregate(average=None)[源代码]#

通常 y_pred 和 y 在每次迭代时存储在累积缓冲区中，此函数读取缓冲区并计算 ROC 下面积。

参数:

average – {"macro", "weighted", "micro", "none"} 如果不是二分类，执行的平均类型。默认为 self.average。

Confusion matrix#

monai.metrics.get_confusion_matrix(y_pred, y, include_background=True)[源代码]#

计算混淆矩阵。将返回形状为 [BC4] 的张量。其中，第三个维度表示输入批处理中每个样本的每个通道的真阳性、假阳性、真阴性和假阴性值数量。其中，B 等于批处理大小，C 等于需要计算的类别数量。

参数:

  • y_pred (Tensor) – 要计算的输入数据。它必须是 one-hot 格式，第一个维度是批量。值应为二值化。

  • y (Tensor) – 用于计算指标的地面真实。它必须是 one-hot 格式，第一个维度是批量。值应为二值化。

  • include_background (bool) – 是否对预测输出的第一个通道进行指标计算。默认为 True。

抛出:

ValueError – 当 y_pred 和 y 形状不同时。

返回类型:

Tensor

monai.metrics.compute_confusion_matrix_metric(metric_name, confusion_matrix)[源代码]#

此函数用于计算与混淆矩阵相关的指标。

参数:

  • metric_name (str) – ["sensitivity", "specificity", "precision", "negative predictive value", "miss rate", "fall out", "false discovery rate", "false omission rate", "prevalence threshold", "threat score", "accuracy", "balanced accuracy", "f1 score", "matthews correlation coefficient", "fowlkes mallows index", "informedness", "markedness"] 一些指标有多个别名（如前面提到的维基百科页面所示），你也可以输入这些名称。

  • confusion_matrix (Tensor) – 请参阅函数 get_confusion_matrix 的文档字符串以获取更多详细信息。

抛出:

  • ValueError – 当 confusion_matrix 的最后一个维度大小不是 4 时。

  • NotImplementedError – 当指定未实现的 metric_name 时。

返回类型:

Tensor

class monai.metrics.ConfusionMatrixMetric(include_background=True, metric_name='hit_rate', compute_sample=False, reduction=mean, get_not_nans=False)[源代码]#

计算与混淆矩阵相关的指标。此函数支持计算 Confusion matrix 中提到的所有指标。它支持多类和多标签分类和分割任务。y_preds 预期是二值化预测，而 y 应该是 one-hot 格式。你可以先使用 monai.transforms.post 中的合适变换来实现二值化值。include_background 参数可以设置为 False 以排除按照惯例被假定为背景的第一个类别（通道索引 0）。如果非背景分割相对于总图像尺寸较小，它们可能会被背景的信号所压倒。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 是否对预测输出的第一个通道进行指标计算。默认为 True。

  • metric_name – ["sensitivity", "specificity", "precision", "negative predictive value", "miss rate", "fall out", "false discovery rate", "false omission rate", "prevalence threshold", "threat score", "accuracy", "balanced accuracy", "f1 score", "matthews correlation coefficient", "fowlkes mallows index", "informedness", "markedness"] 一些指标有多个别名（如上述维基百科页面所示），您也可以输入这些名称。除了只输入一个指标外，还支持输入一个指标名称序列来指定多个指标，例如 (“sensitivity”, “precision”, “recall”)，如果 compute_sample 为 True，则在调用类时，将按照输入的名称顺序返回多个 f 和 not_nans。

  • compute_sample – 进行归约时，如果为 True，则先基于每个混淆矩阵计算每个样本的指标。如果为 False，则先在混淆矩阵上进行归约，默认为 False。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 [(metric, not_nans), …]。如果为 False，aggregate() 返回 [metric, …]。这里的 not_nans 计算真阳性、假阳性、真阴性和假阴性的非 NaN 数量。其形状取决于指标的形状，并且多一个大小为 4 的维度。例如，如果指标的形状是 [3, 3]，则 not_nans 的形状是 [3, 3, 4]。

aggregate(compute_sample=False, reduction=None)[source]#

执行混淆矩阵值的归约。

参数:

  • compute_sample – 进行归约时，如果为 True，则先基于每个混淆矩阵计算每个样本的指标。如果为 False，则先在混淆矩阵上进行归约，默认为 False。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Hausdorff distance#

monai.metrics.compute_hausdorff_distance(y_pred, y, include_background=False, distance_metric='euclidean', percentile=None, directed=False, spacing=None)[source]#

计算 Hausdorff 距离。

参数:

  • y_pred – 用于计算的输入数据，通常是分割模型的输出。必须是 one-hot 格式，并且第一个维度是 batch，例如形状：[16, 3, 32, 32]。值应该是二值化的。

  • y – 用于计算距离平均值的真值。必须是 one-hot 格式，并且第一个维度是 batch。值应该是二值化的。

  • include_background – 是否在预测输出的第一个通道上包含距离计算。默认为 False。

  • distance_metric – : ["euclidean", "chessboard", "taxicab"] 用于计算表面距离的指标。默认为 "euclidean"。

  • percentile – 一个可选的 0 到 100 之间的浮点数。如果指定，将计算 Hausdorff 距离的相应百分位数，而不是最大值。默认为 None。

  • directed – 是否计算有向 Hausdorff 距离。默认为 False。

  • spacing – 像素（或体素）的间距。此参数仅在 distance_metric 设置为 "euclidean" 时相关。如果是一个数字，则批处理中的所有图像都使用该值的各向同性间距。如果是数字序列，则序列的长度必须等于图像维度。此间距将用于批处理中的所有图像。如果是序列的序列，则外部序列的长度必须等于批处理大小。如果内部序列长度为 1，则批处理中的所有图像都使用该值的各向同性间距，否则内部序列长度必须等于图像维度。如果为 None，则批处理中的所有图像都使用单位间距。默认为 None。

monai.metrics.compute_percent_hausdorff_distance(edges_pred, edges_gt, distance_metric='euclidean', percentile=None, spacing=None)[source]#

此函数用于计算有向 Hausdorff 距离。

class monai.metrics.HausdorffDistanceMetric(include_background=False, distance_metric='euclidean', percentile=None, directed=False, reduction=mean, get_not_nans=False)[source]#

计算两个张量之间的 Hausdorff 距离。它支持多类别和多标签任务。它支持有向和无向 Hausdorff 距离计算。此外，指定 percentile 参数可以获取距离的百分位数。输入 y_pred 与真值 y 进行比较。y_preds 期望是二值化的预测，y 应该是 one-hot 格式。您可以先使用 monai.transforms.post 中的适当变换来实现二值化值。y_preds 和 y 可以是通道优先的 Tensor (CHW[D]) 列表，也可以是批处理优先的 Tensor (BCHW[D])。该实现参考了 DeepMind 的实现。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 是否在预测输出的第一个通道上包含距离计算。默认为 False。

  • distance_metric – : ["euclidean", "chessboard", "taxicab"] 用于计算表面距离的指标。默认为 "euclidean"。

  • percentile – 一个可选的 0 到 100 之间的浮点数。如果指定，将计算 Hausdorff 距离的相应百分位数，而不是最大值。默认为 None。

  • directed – 是否计算有向 Hausdorff 距离。默认为 False。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

aggregate(reduction=None)[source]#

对 compute_hausdorff_distance 的输出执行归约逻辑。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Average surface distance#

monai.metrics.compute_average_surface_distance(y_pred, y, include_background=False, symmetric=False, distance_metric='euclidean', spacing=None)[source]#

此函数用于在默认设置下计算从 y_pred 到 y 的平均表面距离。此外，如果设置 symmetric = True，将返回这两个输入之间的平均对称表面距离。该实现参考了 DeepMind 的实现。

参数:

  • y_pred – 用于计算的输入数据，通常是分割模型的输出。必须是 one-hot 格式，并且第一个维度是 batch，例如形状：[16, 3, 32, 32]。值应该是二值化的。

  • y – 用于计算距离平均值的真值。必须是 one-hot 格式，并且第一个维度是 batch。值应该是二值化的。

  • include_background – 是否在预测输出的第一个通道上包含距离计算。默认为 False。

  • symmetric – 是否计算 seg_pred 和 seg_gt 之间的对称平均表面距离。默认为 False。

  • distance_metric – : ["euclidean", "chessboard", "taxicab"] 用于计算表面距离的指标。默认为 "euclidean"。

  • spacing – 像素（或体素）的间距。此参数仅在 distance_metric 设置为 "euclidean" 时相关。如果是一个数字，则批处理中的所有图像都使用该值的各向同性间距。如果是数字序列，则序列的长度必须等于图像维度。此间距将用于批处理中的所有图像。如果是序列的序列，则外部序列的长度必须等于批处理大小。如果内部序列长度为 1，则批处理中的所有图像都使用该值的各向同性间距，否则内部序列长度必须等于图像维度。如果为 None，则批处理中的所有图像都使用单位间距。默认为 None。

class monai.metrics.SurfaceDistanceMetric(include_background=False, symmetric=False, distance_metric='euclidean', reduction=mean, get_not_nans=False)[source]#

计算两个张量之间的表面距离。它支持多类别和多标签任务。它支持对称和非对称表面距离计算。输入 y_pred 与真值 y 进行比较。y_preds 期望是二值化的预测，y 应该是 one-hot 格式。您可以先使用 monai.transforms.post 中的适当变换来实现二值化值。y_preds 和 y 可以是通道优先的 Tensor (CHW[D]) 列表，也可以是批处理优先的 Tensor (BCHW[D])。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • include_background – 是否在预测输出的第一个通道上包含距离计算。默认为 False。

  • symmetric – 是否计算 seg_pred 和 seg_gt 之间的对称平均表面距离。默认为 False。

  • distance_metric – : ["euclidean", "chessboard", "taxicab"] 用于计算表面距离的指标。默认为 "euclidean"。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

aggregate(reduction=None)[source]#

对 compute_average_surface_distance 的输出执行归约逻辑。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Surface dice#

monai.metrics.compute_surface_dice(y_pred, y, class_thresholds, include_background=False, distance_metric='euclidean', spacing=None, use_subvoxels=False)[source]#

此函数计算两个张量 y_pred（表示为 \(\hat{Y}\)）和 y（表示为 \(Y\)）之间的（归一化）表面 Dice (NSD)。该指标确定分割边界的哪个部分被正确预测。如果边界元素到参考边界的最近距离小于或等于与可接受的像素偏差量相关的指定阈值，则认为该边界元素被正确预测。NSD 的取值范围在 0 到 1 之间。

此实现支持多类别任务，其中每个类别 \(c\) 有一个单独的阈值 \(\tau_c\)。批处理索引 \(b\) 的类别特定 NSD，即 \(\operatorname {NSD}_{b,c}\)，使用以下函数计算：

(1)#\[\operatorname {NSD}_{b,c} \left(Y_{b,c}, \hat{Y}_{b,c}\right) = \frac{\left|\mathcal{D}_{Y_{b,c}}^{'}\right| + \left| \mathcal{D}_{\hat{Y}_{b,c}}^{'} \right|}{\left|\mathcal{D}_{Y_{b,c}}\right| + \left|\mathcal{D}_{\hat{Y}_{b,c}}\right|}\]

其中 \(\mathcal{D}_{Y_{b,c}}\) 和 \(\mathcal{D}_{\hat{Y}_{b,c}}\) 是两组最近邻距离。\(\mathcal{D}_{Y_{b,c}}\) 是从预测分割边界到参考分割边界计算的距离，而 \(\mathcal{D}_{\hat{Y}_{b,c}}\) 则反之。\(\mathcal{D}_{Y_{b,c}}^{'}\) 和 \(\mathcal{D}_{\hat{Y}_{b,c}}^{'}\) 指的是小于或等于可接受距离 \(\tau_c\) 的距离子集

\[\mathcal{D}_{Y_{b,c}}^{'} = \{ d \in \mathcal{D}_{Y_{b,c}} \, | \, d \leq \tau_c \}.\]

如果一个类别既不存在于预测分割中，也不存在于参考分割中，则该类别将返回 nan 值。如果一个类别仅存在于预测分割或参考分割之一中，则该类别的 NSD 将为 0。

此实现基于 https://arxiv.org/abs/2111.05408 并支持 2D 和 3D 图像。当 use_subvoxels=True 时，边界的计算遵循 DeepMind 的实现 deepmind/surface-distance；否则，分割边界的长度被解释为其边缘像素的数量。

参数:

  • y_pred – 预测分割，通常是分割模型的输出。它必须是 one-hot 编码的，批处理优先的张量 [B,C,H,W] 或 [B,C,H,W,D]。

  • y – 参考分割。它必须是 one-hot 编码的，批处理优先的张量 [B,C,H,W] 或 [B,C,H,W,D]。

  • class_thresholds – 类别特定阈值列表。这些阈值与像素中可接受的分割边界偏差量相关。每个阈值必须是一个有限的非负数。

  • include_background – 是否在预测输出的第一个通道上包含表面 Dice 计算。默认为 False。

  • distance_metric – 用于计算表面距离的指标。可选值之一：["euclidean", "chessboard", "taxicab"]。默认为 "euclidean"。

  • spacing – 像素（或体素）的间距。此参数仅在 distance_metric 设置为 "euclidean" 时相关。如果是一个数字，则批处理中的所有图像都使用该值的各向同性间距。如果是数字序列，则序列的长度必须等于图像维度。此间距将用于批处理中的所有图像。如果是序列的序列，则外部序列的长度必须等于批处理大小。如果内部序列长度为 1，则批处理中的所有图像都使用该值的各向同性间距，否则内部序列长度必须等于图像维度。如果为 None，则批处理中的所有图像都使用单位间距。默认为 None。

  • use_subvoxels – 是否使用亚体素距离。默认为 False。

抛出:

  • ValueError – 如果 y_pred 和/或 y 不是 PyTorch 张量。

  • ValueError – 如果 y_pred 和/或 y 没有四个维度。

  • ValueError – 如果 y_pred 和/或 y 形状不同。

  • ValueError – 如果 y_pred 和/或 y 不是 one-hot 编码的

  • ValueError – 如果 y_pred 和/或 y 的通道数与类别阈值的数量不同。

  • ValueError – 如果任何类别阈值不是有限的。

  • ValueError – 如果任何类别阈值是负数。

返回:

形状为 [B,C] 的 Pytorch 张量，包含每个批处理索引 \(b\) 和类别 \(c\) 的 NSD 值 \(\operatorname {NSD}_{b,c}\)。

class monai.metrics.SurfaceDiceMetric(class_thresholds, include_background=False, distance_metric='euclidean', reduction=mean, get_not_nans=False, use_subvoxels=False)[source]#

根据公式 (1) 计算预测分割 y_pred 和相应参考分割 y 的每个批处理样本和类别的归一化表面 Dice (NSD)。此实现基于 https://arxiv.org/abs/2111.05408 并支持 2D 和 3D 图像。请注意，默认情况下 (use_subvoxels=False)，边界的计算与 DeepMind 的实现 deepmind/surface-distance 不同。在此实现中，分割边界的长度/面积被解释为其边缘像素的数量。在 DeepMind 的实现中，分割边界的长度取决于局部邻域（参见 https://arxiv.org/abs/1809.04430）。此问题在此处讨论：Project-MONAI/MONAI#4103。

类别和批处理样本的 NSD 值可以使用函数 aggregate 进行聚合。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • class_thresholds – 类别特定阈值列表。这些阈值与像素中可接受的分割边界偏差量相关。每个阈值必须是一个有限的非负数。

  • include_background – 是否在预测输出的第一个通道上包含 NSD 计算。默认为 False。

  • distance_metric – 用于计算表面距离的指标。可选值之一：["euclidean", "chessboard", "taxicab"]。默认为 "euclidean"。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数。默认为 False。not_nans 是指并非所有类别特定 NSD 值都是 NaN 的批处理样本数量。如果设置为 True，函数 aggregate 将同时返回聚合后的 NSD 和 not_nans 计数。如果设置为 False，aggregate 将只返回聚合后的 NSD。

  • use_subvoxels – 是否使用亚体素距离。默认为 False。

aggregate(reduction=None)[source]#

聚合 _compute_tensor 的输出。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

返回:

如果 get_not_nans 设置为 True，此函数返回聚合后的 NSD 和 not_nans 计数。如果 get_not_nans 设置为 False，此函数只返回聚合后的 NSD。

PanopticQualityMetric#

monai.metrics.compute_panoptic_quality(pred, gt, metric_name='pq', remap=True, match_iou_threshold=0.5, smooth_numerator=1e-06, output_confusion_matrix=False)[source]#

计算全景质量 (PQ)。如果将 metric_name 指定为“SQ”或“RQ”，则将返回分割质量 (SQ) 或识别质量 (RQ)。

此外，如果 output_confusion_matrix 为 True，函数将返回一个形状为 4 的张量，代表真阳性、假阳性、假阴性和 IoU 的总和。这四个值用于计算 PQ，直接返回它们可以对所有图像进行进一步计算。

参数:

  • pred (Tensor) – 用于计算的输入数据，必须是 HW 形式且为整数类型。

  • gt (Tensor) – 真值。其形状必须与 pred 相同且为整数类型。

  • metric_name (str) – 输出指标。值可以是“pq”、“sq”或“rq”。

  • remap (bool) – 是否重新映射 pred 和 gt 以确保实例 ID 的连续排序。

  • match_iou_threshold (float) – IoU 阈值，用于确定 pred 和 gt 之间的配对。通常，它应该 ≥ 0.5，此时 pred 和 gt 实例之间的配对是相同的。如果设置 match_iou_threshold < 0.5，此函数将使用 Munkres 分配查找最大数量的唯一配对。

  • smooth_numerator (float) – 添加到分子中的一个小的常数，以避免零。

抛出:

  • ValueError – 当 pred 和 gt 形状不同时。

  • ValueError – 当 match_iou_threshold <= 0.0 或 > 1.0 时。

返回类型:

Tensor

class monai.metrics.PanopticQualityMetric(num_classes, metric_name=pq, reduction=mean_batch, match_iou_threshold=0.5, smooth_numerator=1e-06)[source]#

计算两个实例分割掩模之间的全景质量。如果将 metric_name 指定为“SQ”或“RQ”，则将返回分割质量 (SQ) 或识别质量 (RQ)。

全景质量是全景分割任务中使用的指标。此任务统一了通常不同的语义分割（为每个像素分配一个类别标签）和实例分割（检测并分割每个对象实例）任务。与语义分割相比，全景分割区分属于同一类别的不同实例。与实例分割相比，全景分割不允许重叠，每个像素只能分配一个语义标签和一个实例 ID。更多详情请参考以下论文：https://openaccess.thecvf.com/content_CVPR_2019/papers/Kirillov_Panoptic_Segmentation_CVPR_2019_paper.pdf

此类也参考了以下实现：TissueImageAnalytics/CoNIC

参数:

  • num_classes – 类别数量。该数量不应包含背景类别。

  • metric_name – 输出指标。值可以是“pq”、“sq”或“rq”。除了只输入一个指标外，还支持输入一个指标名称序列来指定多个指标，例如 (“pq”, “sq”, “rq”)。如果输入序列，将返回与输入名称顺序相同的结果列表。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

  • match_iou_threshold – IoU 阈值，用于确定 y_pred 和 y 之间的配对。通常，它应该 ≥ 0.5，此时 y_pred 和 y 实例之间的配对是相同的。如果设置 match_iou_threshold < 0.5，此函数将使用 Munkres 分配查找最大数量的唯一配对。

  • smooth_numerator – 添加到分子中的一个小的常数，以避免零。

aggregate(reduction=None)[source]#

对 compute_panoptic_quality 的输出执行归约逻辑。

参数:

reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 self.reduction。如果为“none”，则不进行归约。

Mean squared error#

class monai.metrics.MSEMetric(reduction=mean, get_not_nans=False)[source]#

使用函数计算两个张量之间的均方误差

\[\operatorname {MSE}\left(Y, \hat{Y}\right) =\frac {1}{n}\sum _{i=1}^{n}\left(y_i-\hat{y_i} \right)^{2}.\]

更多信息：https://en.wikipedia.org/wiki/Mean_squared_error

输入 y_pred 与真值 y 进行比较。y_pred 和 y 都期望是实数值，其中 y_pred 是回归模型的输出。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Mean absolute error#

class monai.metrics.MAEMetric(reduction=mean, get_not_nans=False)[source]#

使用函数计算两个张量之间的平均绝对误差。

\[\operatorname {MAE}\left(Y, \hat{Y}\right) =\frac {1}{n}\sum _{i=1}^{n}\left|y_i-\hat{y_i}\right|.\]

更多信息：https://en.wikipedia.org/wiki/Mean_absolute_error

输入 y_pred 与真值 y 进行比较。y_pred 和 y 都期望是实数值，其中 y_pred 是回归模型的输出。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Root mean squared error#

class monai.metrics.RMSEMetric(reduction=mean, get_not_nans=False)[source]#

使用函数计算两个张量之间的均方根误差。

\[\operatorname {RMSE}\left(Y, \hat{Y}\right) ={ \sqrt{ \frac {1}{n}\sum _{i=1}^{n}\left(y_i-\hat{y_i}\right)^2 } } \ = \sqrt {\operatorname{MSE}\left(Y, \hat{Y}\right)}.\]

更多信息：https://en.wikipedia.org/wiki/Root-mean-square_deviation

输入 y_pred 与真值 y 进行比较。y_pred 和 y 都期望是实数值，其中 y_pred 是回归模型的输出。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Peak signal to noise ratio#

class monai.metrics.PSNRMetric(max_val, reduction=mean, get_not_nans=False)[source]#

使用函数计算两个张量之间的峰值信噪比。

\[\operatorname{PSNR}\left(Y, \hat{Y}\right) = 20 \cdot \log_{10} \left({\mathit{MAX}}_Y\right) \ -10 \cdot \log_{10}\left(\operatorname{MSE\left(Y, \hat{Y}\right)}\right)\]

更多信息：https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio

参考：tensorflow/tensorflow 行 4139

输入 y_pred 与真值 y 进行比较。y_pred 和 y 都期望是实数值，其中 y_pred 是回归模型的输出。

此类指标的典型执行步骤示例遵循 monai.metrics.metric.Cumulative。

参数:

  • max_val – 图像/体数据的动态范围（即允许的最大值和最小值之差，例如 uint8 图像的 255）。

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Structural similarity index measure#

class monai.metrics.regression.SSIMMetric(spatial_dims, data_range=1.0, kernel_type=gaussian, win_size=11, kernel_sigma=1.5, k1=0.01, k2=0.03, reduction=mean, get_not_nans=False)[source]#

计算结构相似性指数 (SSIM)。

\[\operatorname {SSIM}(x,y) =\frac {(2 \mu_x \mu_y + c_1)(2 \sigma_{xy} + c_2)}{((\mu_x^2 + \ \mu_y^2 + c_1)(\sigma_x^2 + \sigma_y^2 + c_2)}\]
更多信息，请访问

https://vicuesoft.com/glossary/term/ssim-ms-ssim/

SSIM 参考论文

Wang, Zhou, et al. “Image quality assessment: from error visibility to structural similarity.” IEEE transactions on image processing 13.4 (2004): 600-612.

参数:

  • spatial_dims – 输入图像的空间维度数量。

  • data_range – 输入图像的值范围。（通常为 1.0 或 255）

  • kernel_type – 核的类型，可以是“gaussian”或“uniform”。

  • win_size – 核的窗口大小。

  • kernel_sigma – 高斯核的标准差。

  • k1 – 用于亮度分母的稳定常数。

  • k2 – 用于对比度分母的稳定常数。

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Multi-scale structural similarity index measure#

class monai.metrics.MultiScaleSSIMMetric(spatial_dims, data_range=1.0, kernel_type=gaussian, kernel_size=11, kernel_sigma=1.5, k1=0.01, k2=0.03, weights=(0.0448, 0.2856, 0.3001, 0.2363, 0.1333), reduction=mean, get_not_nans=False)[source]#

计算多尺度结构相似性指数 (MS-SSIM)。

MS-SSIM 参考论文

Wang, Z., Simoncelli, E.P. and Bovik, A.C., 2003, November. “Multiscale structural similarity for image quality assessment.” In The Thirty-Seventh Asilomar Conference on Signals, Systems & Computers, 2003 (Vol. 2, pp. 1398-1402). IEEE

参数:

  • spatial_dims – 输入图像的空间维度数量。

  • data_range – 输入图像的值范围。（通常为 1.0 或 255）

  • kernel_type – 核的类型，可以是“gaussian”或“uniform”。

  • kernel_size – 核的大小。

  • kernel_sigma – 高斯核的标准差。

  • k1 – 用于亮度分母的稳定常数。

  • k2 – 用于对比度分母的稳定常数。

  • weights – 用于不同分辨率得分下图像相似性和对比度敏感性的参数。

  • reduction – 定义指标的归约模式，仅对 not-nan 值执行归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。

Fréchet Inception Distance#

monai.metrics.compute_frechet_distance(mu_x, sigma_x, mu_y, sigma_y, epsilon=1e-06)[source]#

多元正态分布之间的 Fréchet 距离。

返回类型:

Tensor

class monai.metrics.FIDMetric[source]#

Fréchet Inception距离 (FID)。FID 计算两个特征向量分布之间的距离。基于：Heusel M. 等人。“通过双时间尺度更新规则训练的 Gans 收敛到局部纳什均衡。” https://arxiv.org/abs/1706.08500。此指标的输入应该是从预训练网络提取的两组特征向量（格式为（图像数量，特征数量））。

最初，建议使用经过 Imagenet 预训练的 Inception v3 的 pool_3 层的激活。然而，也可以使用在医学数据集上预训练的其他网络（例如，用于 2D 图像的 RadImageNwt 和用于 3D 图像的 MedicalNet）。如果选择的模型输出不是标量，应使用全局空间平均池化。

Maximum Mean Discrepancy#

monai.metrics.compute_mmd(y, y_pred, y_mapping)[source]#
参数:

  • y – 第一个样本（例如，参考图像）。对于 2D 数据，其形状为 (B,C,W,H)，对于 3D 数据为 (B,C,W,H,D)。

  • y_pred – 第二个样本（例如，重建图像）。其形状与 y 类似。

  • y_mapping – 在计算指标之前用于转换 y 张量的可调用对象。

class monai.metrics.MMDMetric(y_mapping=None)[source]#

无偏最大均值差异 (MMD) 是一种基于核的方法，用于衡量两个分布之间的相似性。它是一个非负指标，值越小表示两个分布之间的匹配越接近。

Gretton, A., et al,, 2012. A kernel two-sample test. The Journal of Machine Learning Research, 13(1), pp.723-773.

参数:

y_mapping – 在计算指标之前用于转换 y 张量的可调用对象。它通常是高斯或拉普拉斯滤波器，但也可以是任何接受张量作为输入并返回张量作为输出的函数，例如特征提取器或恒等函数。例如 y_mapping = lambda x: x.square()。

Cumulative average#

class monai.metrics.CumulativeAverage[source]#

一个用于跟踪平均值的实用类。例如，在训练/验证循环中，我们需要累积每个批处理的指标，并计算整个数据集的最终平均值。在多 GPU 环境中，使用 DistributedDataParallel 进行训练时，它将在不同进程之间取平均。

示例

from monai.metrics import CumulativeAverage

run_avg = CumulativeAverage()
batch_size = 8
for i in range(len(train_set)):
    ...
    val = calc_metric(x,y) #some metric value
    run_avg.append(val, count=batch_size)

val_avg = run_avg.aggregate() #average value
aggregate(to_numpy=True)[source]#

返回总平均值（在不同进程之间取平均）

参数:

to_numpy (bool) – 是否转换为 numpy 数组。默认为 True

返回类型:

Union[ndarray, Tensor]

append(val, count=1)[source]#
追加新值和可选计数。支持任何可以转换为

使用 torch.as_tensor() 转换的数据类型，例如 number、list、numpy 数组或 Tensor。

参数:

  • val – 要跟踪的值（例如 number、list、numpy 数组或 Tensor）

  • count – 计数（例如 number、list、numpy 数组或 Tensor），用于更新贡献计数

例如

# 简单的常数跟踪 avg = CumulativeAverage() avg.append(0.6) avg.append(0.8) print(avg.aggregate()) #打印 0.7

# 数组跟踪，例如来自 3 个类别的指标 avg= CumulativeAverage() avg.append([0.2, 0.4, 0.4]) avg.append([0.4, 0.6, 0.4]) print(avg.aggregate()) #打印 [0.3, 0.5. 0.4]

# 不同的贡献 / 计数 avg= CumulativeAverage() avg.append(1, count=4) # 来自一个批处理（大小为 4）的指标平均值 1 avg.append(2, count=6) # 来自一个批处理（大小为 6）的指标平均值 2 print(avg.aggregate()) #打印 1.6 == (1*4 +2*6)/(4+6)

# 不同的贡献 / 计数 avg= CumulativeAverage() avg.append([0.5, 0.5, 0], count=[1, 1, 0]) # 最后一个元素的计数为零，表示忽略它 avg.append([0.5, 0.5, 0.5], count=[1, 1, 1]) # print(avg.aggregate()) #打印 [0.5, 0.5, 0,5] == ([0.5, 0.5, 0] + [0.5, 0.5, 0.5]) / ([1, 1, 0] + [1, 1, 1])

get_current(to_numpy=True)[source]#

返回最新值（在不同进程之间取平均）

参数:

to_numpy (bool) – 是否转换为 numpy 数组。默认为 True

返回类型:

Union[ndarray, Tensor]

reset()[source]#

重置所有统计信息。

返回类型:

None

Metrics reloaded binary#

class monai.metrics.MetricsReloadedBinary(metric_name, include_background=True, reduction=mean, get_not_nans=False)[source]#

包装 MetricsReloaded 的二进制成对指标。

参数:

  • metric_name – MetricsReloaded 包中的二进制指标名称。

  • include_background – 是否在预测输出的第一个通道上包含计算。默认为 True。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

示例

import torch
from monai.metrics import MetricsReloadedBinary

metric_name = "Cohens Kappa"
metric = MetricsReloadedBinary(metric_name=metric_name)

# first iteration
# shape [batch=1, channel=1, 2, 2]
y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 1.0]]]])
y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])
print(metric(y_pred, y))

# second iteration
# shape [batch=1, channel=1, 2, 2]
y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 0.0]]]])
y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])
print(metric(y_pred, y))

# aggregate
# shape ([batch=2, channel=1])
print(metric.aggregate(reduction="none"))  # tensor([[0.5], [0.2]])

# reset
metric.reset()

Metrics reloaded categorical#

class monai.metrics.MetricsReloadedCategorical(metric_name, include_background=True, reduction=mean, get_not_nans=False, smooth_dr=1e-05)[source]#

包装 MetricsReloaded 的分类成对指标。

参数:

  • metric_name – MetricsReloaded 包中的分类指标名称。

  • include_background – 是否在预测输出的第一个通道上包含计算。默认为 True。

  • reduction – 定义指标的归约模式，仅应用于 not-nan 值，可用的归约模式有：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则不进行归约。

  • get_not_nans – 是否返回 not_nans 计数，如果为 True，aggregate() 返回 (metric, not_nans)。此处 not_nans 计算指标中非 NaN 的数量，因此其形状等于指标的形状。

  • smooth_dr – 添加到分母中的一个小的常数，以避免 NaN。注意：应大于零。

示例

import torch
from monai.metrics import MetricsReloadedCategorical

metric_name = "Weighted Cohens Kappa"
metric = MetricsReloadedCategorical(metric_name=metric_name)

# first iteration
# shape [bach=1, channel=3, 2, 2]
y_pred = torch.tensor([[[[0, 0], [0, 1]], [[0, 0], [0, 0]], [[1, 1], [1, 0]]]])
y = torch.tensor([[[[1, 0], [0, 1]], [[0, 1], [0, 0]], [[0, 0], [1, 0]]]])
print(metric(y_pred, y))

# second iteration
# shape [batch=1, channel=3, 2, 2]
y_pred = torch.tensor([[[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, 0], [0, 0]]]])
y = torch.tensor([[[[1, 0], [0, 1]], [[0, 1], [0, 0]], [[0, 0], [1, 0]]]])
print(metric(y_pred, y))

# aggregate
# shape ([batch=2, channel=1])
print(metric.aggregate(reduction="none"))  # tensor([[0.2727], [0.6000]])

# reset
metric.reset()

工具函数#

monai.metrics.utils.do_metric_reduction(f, reduction=mean)[source]#

此函数用于对每个样本的每个类别的计算出的 not-nan 指标进行归约。此函数还返回 not_nans，它计算指标的非 NaN 数量。

参数:

  • f – 一个张量，包含每个批处理和每个类别的计算出的指标得分。前两个维度应该是批处理和类别。

  • reduction – 定义指标的归约模式，仅对 not-nan 值应用归约，可用的归约模式：{"none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"}，默认为 "mean"。如果为“none”，则返回输入的 f 张量和 not_nans。

抛出:

ValueError – 当 reduction 不是 [“mean”, “sum”, “mean_batch”, “sum_batch”, “mean_channel”, “sum_channel” “none”] 中的一个时。

monai.metrics.utils.get_code_to_measure_table(spacing, device=None)[source]#

返回一个将邻域代码映射到表面积或轮廓长度的表。

参数:

  • spacing – 2 或 3 个数字的序列，表示空间维度中的间距。

  • device – 放置表的设备。

monai.metrics.utils.get_mask_edges(seg_pred, seg_gt, label_idx=1, crop=True, spacing=None, always_return_as_numpy=True)[source]#

从二进制分割掩模计算边缘。此函数有助于进一步计算平均表面距离和 Hausdorff 距离等指标。输入图像可以是二进制或标签场图像。如果提供标签场图像，则使用 label_idx 将其转换为二进制图像。

为了提高计算效率，在获取边缘之前，如果未指定 crop = False，则可以裁剪图像并仅保留前景。

我们要求图像尺寸相同，并假定它们占用相同的空间（间距、方向等）。

参数:

  • seg_pred – 预测的二进制或标签场图像。

  • seg_gt – 实际的二进制或标签场图像。

  • label_idx – 对于标签场图像，使用 seg_pred = seg_pred == label_idx 转换为二进制。

  • crop – 裁剪输入图像并仅保留前景。为了保持两个输入的形状，此处通过 (seg_pred | seg_gt) 获取边界框，这代表了两个图像的并集。默认为 True。

  • spacing – 输入间距。如果不为 None，将计算亚体素边缘和面积；否则，使用 scipy 的二进制腐蚀计算边缘。

  • always_return_as_numpy – 无论输入类型如何，是否返回 numpy 数组。如果为 False，则返回与输入相同的类型。

monai.metrics.utils.get_surface_distance(seg_pred, seg_gt, distance_metric='euclidean', spacing=None)[source]#

此函数用于计算从 seg_pred 到 seg_gt 的表面距离。

参数:

  • seg_pred – 预测的边缘。

  • seg_gt – 真值的边缘。

  • distance_metric –

    : ["euclidean", "chessboard", "taxicab"] 用于计算表面距离的指标。默认为 "euclidean"。

    • "euclidean"，使用精确欧几里得距离变换。

    • "chessboard"，在倒角类型变换中使用 chessboard 指标。

    • "taxicab"，在倒角类型变换中使用 taxicab 指标。

  • spacing – 像素（或体素）的间距。此参数仅在 distance_metric 设置为 "euclidean" 时相关。允许几种输入选项：(1) 如果是单个数字，则使用该值的各向同性间距。(2) 如果是数字序列，则序列的长度必须等于图像维度。(3) 如果为 None，则使用单位间距。默认为 None。

注意

如果 seg_pred 或 seg_gt 全为 0，可能导致 nan/inf 距离。

monai.metrics.utils.ignore_background(y_pred, y)[源代码]#

此函数用于移除 y_pred 和 y 的背景（第一个通道）。

参数:

  • y_pred (~NdarrayTensor) – 预测值。对于分类任务，y_pred 的形状应为 [BN]，其中 N 大于 1。对于分割任务，形状应为 [BNHW] 或 [BNHWD]。

  • y (~NdarrayTensor) – 真值，第一个维度是批次。

返回类型:

tuple[~NdarrayTensor, ~NdarrayTensor]

monai.metrics.utils.is_binary_tensor(input, name)[源代码]#

判断输入张量是否是 PyTorch 二值张量。

参数:

  • input (torch.Tensor) – 要验证的张量。

  • name (str) – 正在检查的张量的名称。

抛出:

ValueError – 如果 input 不是 PyTorch 张量。

注意

如果张量不是二值，则会打印警告消息。

返回类型:

None

monai.metrics.utils.prepare_spacing(spacing, batch_size, img_dim)[源代码]#

此函数用于准备 spacing 参数，使其包含批次维度，以便计算表面距离、Hausdorff 距离或表面 Dice 系数。

一个 batch_size = 4 和 img_dim = 3 的例子：输入 spacing = None -> 输出 spacing = [None, None, None, None] 输入 spacing = 0.8 -> 输出 spacing = [0.8, 0.8, 0.8, 0.8] 输入 spacing = [0.8, 0.5, 0.9] -> 输出 spacing = [[0.8, 0.5, 0.9], [0.8, 0.5, 0.9], [0.8, 0.5, 0.9], [0.8, 0.5, 0.9]] 输入 spacing = [0.8, 0.7, 1.2, 0.8] -> 输出 spacing = [0.8, 0.7, 1.2, 0.8] （与输入相同）

一个 batch_size = 3 和 img_dim = 3 的例子：输入 spacing = [0.8, 0.5, 0.9] -> 输出 spacing = [[0.8, 0.5, 0.9], [0.8, 0.5, 0.9], [0.8, 0.5, 0.9]]

参数:

  • spacing – 可以是浮点数、长度为 img_dim 的序列，或者长度为 batch_size 的序列

  • that includes floats or sequences of length img_dim. – 其中包含浮点数或长度为 img_dim 的序列。

抛出:

  • ValueError – 当 spacing 是序列的序列时，如果外部序列的长度不

  • equal batch_size or inner sequence length does not equal img_dim. – 等于 batch_size，或内部序列的长度不等于 img_dim。

返回:

一个长度为 batch_size 的序列，其中包含整数、浮点数或长度为 img_dim 的序列。

返回类型:

spacing

monai.metrics.utils.remap_instance_id(pred, by_size=False)[源代码]#

此函数用于重命名 pred 的所有实例 ID，使其连续。例如：输入的所有 ID 可以是 [0, 1, 2]，而不是 [0, 2, 5]。此函数对于计算全景质量 (PQ) 等指标非常有用。实现参考了

vqdang/hover_net

参数:

  • pred (Tensor) – PyTorch 张量形式的分割预测值。张量的每个值都应为整数，表示其对应实例 ID 的预测。

  • by_size (bool) – 如果为 True，则将最大的实例分配一个较小的 ID。

返回类型:

Tensor

在本页上
显示源代码