事件处理程序#

模型检查点加载器#

class monai.handlers.CheckpointLoader(load_path, load_dict, name=None, map_location=None, strict=True, strict_shape=True)[source]#

CheckpointLoader 作为 Ignite 处理程序，用于从文件加载检查点数据。它可以加载网络、优化器、学习率调度器等变量。如果在 torch.nn.DataParallel 之后保存检查点，需要按照 PyTorch 的建议保存 model.module，然后使用此加载器加载模型。

使用示例

trainer = SupervisedTrainer(...)
save_dict = {
    "trainer": trainer,
    "net": network,
    "opt": optimizer,
    "lr": lr_scheduler,
}

map_location = "cuda:0"
# checkpoint needs to have same save_dict for this to work
handler = CheckpointLoader(load_path="/test/checkpoint.pt", load_dict=save_dict, map_location=map_location, strict=True)
handler(trainer)
# Trainer now has the same state as stored, including the number of epochs and iterations completed
# so you can resume an interrupted training at the place where it left
参数:

  • load_path – 检查点文件的路径，应为 PyTorch pth 文件。

  • load_dict –

    用于加载检查点的目标对象。示例

    {'network': net, 'optimizer': optimizer, 'lr_scheduler': lr_scheduler}

  • name – 要使用的 logging.logger 的标识符，如果为 None，则默认为 engine.logger。

  • map_location – 在加载分布式训练/评估模块时，需要提供合适的 map_location 参数以防止一个进程进入其他设备的内存。如果 map_location 缺失，torch.load 将首先将模块加载到 CPU，然后将每个参数复制到保存的位置，这将导致同一台机器上的所有进程使用同一组设备。

  • strict – 是否严格执行 load_dict 中每个项的 state_dict 中的键和数据形状与检查点中对应项的 state_dict 匹配，默认为 True。

  • strict_shape – 是否强制检查点中匹配层的形状，如果为 False，它将跳过与检查点内容具有不同形状的层，并忽略 strict 参数。这对于迁移学习可能是一个有用的高级功能。用户应完全理解哪些层将具有不同的形状。默认为 True。

注意: 如果 strict_shape=False，将只加载 torch.nn.Module 的检查点并跳过其他

load_dict 中的项。例如，如果当前模型中某些层的形状与检查点不匹配，则当前优化器的 parameter_group 可能也与检查点不匹配，因此跳过为优化器加载检查点。

有关加载检查点的更多详细信息，请参阅：https://pytorch.ac.cn/ignite/v0.4.5/generated/ignite.handlers.checkpoint.Checkpoint.html #ignite.handlers.checkpoint.Checkpoint.load_objects. https://pytorch.ac.cn/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.load_state_dict。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

模型检查点保存器#

class monai.handlers.CheckpointSaver(save_dir, save_dict, name=None, file_prefix='', save_final=False, final_filename=None, save_key_metric=False, key_metric_name=None, key_metric_n_saved=1, key_metric_filename=None, key_metric_save_state=False, key_metric_greater_or_equal=False, key_metric_negative_sign=False, epoch_level=True, save_interval=0, n_saved=None)[source]#

CheckpointSaver 作为 Ignite 处理程序，用于将检查点数据保存到文件。它支持根据指标结果、epoch 数、迭代数以及最后一个模型或异常情况进行保存。

参数:

  • save_dir – 保存检查点的目标目录。

  • save_dict –

    用于保存到检查点的源对象。示例

    {'network': net, 'optimizer': optimizer, 'lr_scheduler': lr_scheduler}

  • name – 要使用的 logging.logger 的标识符，如果为 None，则默认为 engine.logger。

  • file_prefix – 保存对象的 文件名的前缀。

  • save_final – 是否在最终迭代或异常发生时保存检查点或会话。如果要在引发异常时保存检查点，请将此处理程序放在处理程序列表中的 StatsHandler 之前，因为 Ignite 的逻辑对于 EXCEPTION_RAISED 事件只能触发第一个附加的处理程序。

  • final_filename – 如果 save_final=True，则设置一个固定的文件名来保存最终模型。如果为 None，默认为 checkpoint_final_iteration=N.pt。

  • save_key_metric – 在训练期间，当 key_metric 的值高于所有先前值时是否保存检查点或会话。保留指标的 4 位小数，检查点名称为：{file_prefix}_key_metric=0.XXXX.pth。

  • key_metric_name – ignite 指标字典中 key_metric 的名称。如果为 None，则改用 engine.state.key_metric。

  • key_metric_n_saved – 保存按关键指标值降序排序的前 N 个检查点或会话。

  • key_metric_filename – 设置一个固定的文件名来设置最佳指标模型，如果不是 None，则 key_metric_n_saved 应为 1 并且只保留最佳指标模型。

  • key_metric_save_state – 是否在检查点文件中保存关键指标的跟踪列表。如果为 True，则将在检查点文件中保存一个键为 checkpointer 的对象，以与 ignite 中 Checkpoint 的 include_self 参数保持一致：https://pytorch.ac.cn/ignite/v0.4.5/generated/ignite.handlers.checkpoint.Checkpoint.html。通常，这用于恢复训练并将当前指标与之前的 N 个值进行比较。

  • key_metric_greater_or_equal – 如果为 True，则存储最新的得分相同的模型。否则，保存第一个得分相同的模型。默认为 False。

  • key_metric_negative_sign – 是否在指标分数上添加负号以进行比较，因为对于误差类指标，越小越好（分数越大的对象被保留）。默认为 False。

  • epoch_level – 在训练期间每 N 个 epoch 或每 N 次迭代保存检查点。True 表示 epoch 级别，False 表示迭代级别。

  • save_interval – 每 N 个 epoch 保存检查点，默认为 0 表示不保存检查点。

  • n_saved – 保存 epoch 级别或迭代级别的最新 N 个检查点，‘None’ 表示保存所有。

注意

CheckpointHandler 可用于训练、验证或评估期间。保存文件的示例

  • checkpoint_iteration=400.pt

  • checkpoint_iteration=800.pt

  • checkpoint_epoch=1.pt

  • checkpoint_final_iteration=1000.pt

  • checkpoint_key_metric=0.9387.pt

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

completed(engine)[source]#

训练或验证/评估完成事件的回调。如果配置 save_final 为 True，则保存最终检查点。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

exception_raised(engine, e)[source]#

训练或验证/评估异常事件的回调。如果配置 save_final 为 True，则将当前数据保存为最终检查点。此回调可能会被跳过，因为 Ignite 的逻辑对于 EXCEPTION_RAISED 事件只能触发第一个附加的处理程序。

参数:

  • engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

  • e (Exception) – 在 Ignite 引擎运行期间捕获的异常。

返回类型:

None

interval_completed(engine)[source]#

训练 epoch/迭代完成事件的回调。如果配置 save_interval = N，则保存检查点。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

load_state_dict(state_dict)[source]#

用于恢复关键指标跟踪列表内部状态的实用程序，如果配置为根据关键指标值保存检查点。请注意在保存先前的检查点时设置 key_metric_save_state=True。

示例

CheckpointSaver(
    ...
    save_key_metric=True,
    key_metric_save_state=True,  # config to also save the state of this saver
).attach(engine)
engine.run(...)

# resumed training with a new CheckpointSaver
saver = CheckpointSaver(save_key_metric=True, ...)
# load the previous key metric tracking list into saver
CheckpointLoader("/test/model.pt"), {"checkpointer": saver}).attach(engine)
返回类型:

None

metrics_completed(engine)[source]#

在训练或验证 epoch 完成时比较指标并保存模型的回调。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

指标保存器#

class monai.handlers.MetricsSaver(save_dir, metrics='*', metric_details=None, batch_transform=<function MetricsSaver.<lambda>>, summary_ops=None, save_rank=0, delimiter=', ', output_type='csv')[source]#

Ignite 处理程序，用于将指标值和详细信息保存到指定文件。

参数:

  • save_dir – 保存指标和指标详细信息的目录。

  • metrics – 预期保存到文件的最终指标，可以是: None, “*” 或字符串列表。None - 不保存任何指标到文件。“*” - 将 engine.state.metrics 字典中所有现有指标保存到单独的文件。字符串列表 - 指定要保存的预期指标。默认为 “*” 将所有指标保存到 metrics.csv。

  • metric_details – 预期保存到文件的指标详细信息，数据来自 engine.state.metric_details，应由不同的 Metrics 提供，通常是指标计算中的一些中间值。例如：验证数据集中每张图像的每个通道的平均 Dice。它必须至少包含 2 个维度：(batch, classes, …)，否则将 unsqueeze 到 2 个维度。此参数可以是: None, “*” 或字符串列表。None - 不保存任何指标详细信息到文件。“*” - 将 engine.state.metric_details 字典中所有现有指标详细信息保存到单独的文件。字符串列表 - 指定要保存的预期指标详细信息。如果不是 None，每个指标详细信息数组将保存一个单独的 {metric name}_raw.csv 文件。

  • batch_transform – 如果保存指标详细信息，此可调用对象用于从 ignite.engine.state.batch 中提取输入图像的 meta_data 字典。目的是从 meta_data 中获取输入文件名并与指标详细信息一起存储。engine.state 和 batch_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • summary_ops –

    预期用于生成摘要报告的计算操作。可以是: None, “*” 或字符串列表，默认为 None。None - 不为每个预期的 metric_details 生成摘要报告。“*” - 为每个 metric_details 生成包含所有支持操作的摘要报告。字符串列表 - 为每个 metric_details 生成包含指定操作的摘要报告，它们应在列表 [“mean”, “median”, “max”, “min”, “<int>percentile”, “std”, “notnans”] 中。“<int>percentile” 中的数字应在 [0, 100] 范围内，例如：“15percentile”。默认为：“90percentile”。更多详细信息，请参阅：https://numpy.com.cn/doc/stable/reference/generated/numpy.nanpercentile.html。请注意：对于总体摘要，它首先计算每张图像所有类别的 nanmean，然后再计算摘要。生成的摘要报告示例

    class    mean    median    max    5percentile 95percentile  notnans
class0  6.0000   6.0000   7.0000   5.1000      6.9000       2.0000
class1  6.0000   6.0000   6.0000   6.0000      6.0000       1.0000
mean    6.2500   6.2500   7.0000   5.5750      6.9250       2.0000

  • save_rank – 在多 GPU 验证中，只有指定 rank 上的处理程序才会保存到文件，默认为 0。

  • delimiter – 保存文件中的分隔符，默认为 “,”，因为默认输出类型为 csv。与以下保持一致：https://docs.pythonlang.cn/3/library/csv.html#csv.Dialect.delimiter。

  • output_type – 预期输出文件类型，支持的类型：[“csv”]，默认为 “csv” 。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

CSV 保存器#

class monai.handlers.ClassificationSaver(output_dir='./', filename='predictions.csv', delimiter=', ', overwrite=True, batch_transform=<function ClassificationSaver.<lambda>>, output_transform=<function ClassificationSaver.<lambda>>, name=None, save_rank=0, saver=None)[source]#

在完成每次迭代时触发的事件处理程序，用于将分类预测保存为 CSV 文件。如果在分布式数据并行模式下运行，则仅在指定 rank 上保存 CSV 文件。

__init__(output_dir='./', filename='predictions.csv', delimiter=', ', overwrite=True, batch_transform=<function ClassificationSaver.<lambda>>, output_transform=<function ClassificationSaver.<lambda>>, name=None, save_rank=0, saver=None)[source]#
参数:

  • output_dir – 如果 saver=None，输出 CSV 文件目录。

  • filename – 如果 saver=None，保存的 CSV 文件名。

  • delimiter – 保存文件中的分隔符，默认为 “,”，因为默认输出类型为 csv。与以下保持一致：https://docs.pythonlang.cn/3/library/csv.html#csv.Dialect.delimiter。

  • overwrite – 如果 saver=None，是否覆盖现有文件内容，如果为 True，则在保存前会清空文件。否则，会将新内容附加到文件。

  • batch_transform – 此可调用对象用于从 ignite.engine.state.batch 中提取输入图像的 meta_data 字典。目的是从 meta_data 中获取输入文件名并与分类结果一起存储。engine.state 和 batch_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • output_transform – 此可调用对象用于从 ignite.engine.state.output 中提取模型预测数据。其输出的第一个维度将被视为批处理维度。批处理中的每个项将单独保存。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • name – 要使用的 logging.logger 的标识符，默认为 engine.logger。

  • save_rank – 在多 GPU 验证中，只有指定 rank 上的处理程序才会保存到 CSV 文件，默认为 0。

  • saver – 用于保存分类结果的保存器实例，如果为 None，则在内部创建一个 CSVSaver。该保存器必须提供 save_batch(batch_data, meta_data) 和 finalize() API。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

Ignite 指标处理程序#

class monai.handlers.IgniteMetricHandler(metric_fn=None, loss_fn=None, output_transform=<function IgniteMetricHandler.<lambda>>, save_details=True, reduction=mean, get_not_nans=False)[source]#

基于 ignite 事件处理机制的基础指标类。输入 prediction 或 label 数据可以是带有批处理维度和通道维度的 PyTorch Tensor 或 numpy 数组，也可以是不带批处理维度的 PyTorch Tensor 或 numpy 数组列表。

参数:

  • metric_fn – 可调用的函数或类，用于在每次迭代后计算原始指标结果。期望返回形状为 (batch, channel, …) 的 Tensor 或元组 (Tensor, not_nans)。

  • loss_fn – 用于生成 LossMetric 的 torch _Loss 函数

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的 mean_dice。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

  • reduction – LossMetric 的参数，详见其说明

  • get_not_nans – LossMetric 的参数，详见其说明

attach(engine, name)[source]#

将当前指标附加到提供的引擎。在引擎运行结束时，engine.state.metrics 字典将在提供的名称下包含计算出的指标值。

参数:

  • engine (Engine) – 必须附加指标的引擎。

  • name (str) – 要附加的指标的名称。

返回类型:

None

compute()[source]#
抛出:

NotComputableError – 当在发生 update 之前调用 compute 时。

返回类型:

Any

reset()#

将指标重置为其初始状态。

默认情况下，这在每个 epoch 开始时调用。

返回类型:

None

update(output)#
参数:

output (Sequence[Tensor]) – 包含 [y_pred, y] 内容的序列。

抛出:

ValueError – 当 output 长度不是 2 时。metric_fn 仅支持 y_pred 和 y。

返回类型:

None

平均 Dice 指标处理程序#

class monai.handlers.MeanDice(include_background=True, reduction=mean, num_classes=None, output_transform=<function MeanDice.<lambda>>, save_details=True, return_with_label=False)[source]#

从全尺寸 Tensor 计算 Dice 分数指标，并在批处理、类别通道、迭代之间收集平均值。

__init__(include_background=True, reduction=mean, num_classes=None, output_transform=<function MeanDice.<lambda>>, save_details=True, return_with_label=False)[source]#
参数:

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

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

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的平均 Dice。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

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

另请参阅

monai.metrics.meandice.compute_dice()

平均 IoU 指标处理程序#

class monai.handlers.MeanIoUHandler(include_background=True, reduction=mean, output_transform=<function MeanIoUHandler.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算 IoU 分数指标，并在批处理、类别通道、迭代之间收集平均值。

__init__(include_background=True, reduction=mean, output_transform=<function MeanIoUHandler.<lambda>>, save_details=True)[source]#
参数:

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

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的平均 IoU。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.meaniou.compute_iou()

ROC AUC 指标处理程序#

class monai.handlers.ROCAUC(average=macro, output_transform=<function ROCAUC.<lambda>>)[source]#

计算接收者操作特征曲线下面积 (ROC AUC)。在 epoch 期间累积预测和真实值并应用 compute_roc_auc。

参数:

  • average –

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

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

      这不考虑标签不平衡。

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

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

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

      指示矩阵作为一个标签。

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

注意

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

混淆矩阵指标处理程序#

class monai.handlers.ConfusionMatrix(include_background=True, metric_name='hit_rate', compute_sample=False, reduction=mean, output_transform=<function ConfusionMatrix.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算与混淆矩阵相关的指标，并在批处理、类别通道、迭代之间收集平均值。

__init__(include_background=True, metric_name='hit_rate', compute_sample=False, reduction=mean, output_transform=<function ConfusionMatrix.<lambda>>, save_details=True)[source]#
参数:

  • 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"] 某些指标具有多个别名（如前述维基百科页面所示），您也可以输入这些名称。

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

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的 TP/TN/FP/FN。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.confusion_matrix()

Hausdorff 距离指标处理程序#

class monai.handlers.HausdorffDistance(include_background=False, distance_metric='euclidean', percentile=None, directed=False, reduction=mean, output_transform=<function HausdorffDistance.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算 Hausdorff 距离，并在批处理、类别通道、迭代之间收集平均值。

__init__(include_background=False, distance_metric='euclidean', percentile=None, directed=False, reduction=mean, output_transform=<function HausdorffDistance.<lambda>>, save_details=True)[source]#
参数:

  • 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”，则不进行归约。

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的 Hausdorff 距离。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

表面距离指标处理程序#

class monai.handlers.SurfaceDistance(include_background=False, symmetric=False, distance_metric='euclidean', reduction=mean, output_transform=<function SurfaceDistance.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算表面距离，并在批处理、类别通道、迭代之间收集平均值。

__init__(include_background=False, symmetric=False, distance_metric='euclidean', reduction=mean, output_transform=<function SurfaceDistance.<lambda>>, save_details=True)[source]#
参数:

  • 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”，则不进行归约。

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的表面 Dice。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

全景质量指标处理程序#

class monai.handlers.PanopticQuality(num_classes, metric_name='pq', reduction=mean_batch, match_iou_threshold=0.5, smooth_numerator=1e-06, output_transform=<function PanopticQuality.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算全景质量，并在批处理、类别通道、迭代之间收集平均值。

__init__(num_classes, metric_name='pq', reduction=mean_batch, match_iou_threshold=0.5, smooth_numerator=1e-06, output_transform=<function PanopticQuality.<lambda>>, save_details=True)[source]#
参数:

  • num_classes – 类别数。此数字不应包含背景。

  • metric_name – 输出指标。值可以是 “pq”, “sq” 或 “rq”。

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

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

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的全景质量。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.panoptic_quality.compute_panoptic_quality()

均方误差指标处理程序#

class monai.handlers.MeanSquaredError(reduction=mean, output_transform=<function MeanSquaredError.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算均方误差，并在批处理、迭代之间收集平均值。

__init__(reduction=mean, output_transform=<function MeanSquaredError.<lambda>>, save_details=True)[source]#
参数:

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的均方误差。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.MSEMetric

平均绝对误差指标处理程序#

class monai.handlers.MeanAbsoluteError(reduction=mean, output_transform=<function MeanAbsoluteError.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算平均绝对误差，并在批处理、迭代之间收集平均值。

__init__(reduction=mean, output_transform=<function MeanAbsoluteError.<lambda>>, save_details=True)[source]#
参数:

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的均方误差。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.MAEMetric

均方根误差指标处理程序#

class monai.handlers.RootMeanSquaredError(reduction=mean, output_transform=<function RootMeanSquaredError.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算均方根误差，并在批处理、迭代之间收集平均值。

__init__(reduction=mean, output_transform=<function RootMeanSquaredError.<lambda>>, save_details=True)[source]#
参数:

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的均方误差。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.RMSEMetric

峰值信噪比指标处理程序#

class monai.handlers.PeakSignalToNoiseRatio(max_val, reduction=mean, output_transform=<function PeakSignalToNoiseRatio.<lambda>>, save_details=True)[source]#

从全尺寸 Tensor 计算峰值信噪比，并在批处理、迭代之间收集平均值。

__init__(max_val, reduction=mean, output_transform=<function PeakSignalToNoiseRatio.<lambda>>, save_details=True)[source]#
参数:

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

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

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的均方误差。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

  • reduction – {"none", "mean", "sum", "mean_batch", "sum_batch",

另请参阅

monai.metrics.PSNRMetric

Metrics Reloaded 二元处理程序#

class monai.handlers.MetricsReloadedBinaryHandler(metric_name, include_background=True, reduction=mean, get_not_nans=False, output_transform=<function MetricsReloadedBinaryHandler.<lambda>>, save_details=True)[source]#

MetricsReloadedBinary 的处理程序，它封装了 MetricsReloaded 的二元成对指标。

__init__(metric_name, include_background=True, reduction=mean, get_not_nans=False, output_transform=<function MetricsReloadedBinaryHandler.<lambda>>, save_details=True)[source]#
参数:

  • 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 数量，因此其形状与指标的形状相同。

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的 TP/TN/FP/FN。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.wrapper()

Metrics Reloaded 分类处理程序#

class monai.handlers.MetricsReloadedCategoricalHandler(metric_name, include_background=True, reduction=mean, get_not_nans=False, smooth_dr=1e-05, output_transform=<function MetricsReloadedCategoricalHandler.<lambda>>, save_details=True)[source]#

MetricsReloadedCategorical 的处理程序，它封装了 MetricsReloaded 的分类成对指标。

__init__(metric_name, include_background=True, reduction=mean, get_not_nans=False, smooth_dr=1e-05, output_transform=<function MetricsReloadedCategoricalHandler.<lambda>>, save_details=True)[source]#
参数:

  • 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。注意：应大于零。

  • output_transform – 可调用对象，用于从 ignite.engine.state.output 中提取 y_pred 和 y，然后构建 (y_pred, y) 对，其中 y_pred 和 y 可以是 batch-first Tensor 或 channel-first Tensor 的列表。update() 方法需要 (y_pred, y) 的形式。engine.state 和 output_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • save_details – 是否保存每张图像的指标计算详细信息，例如：每张图像的 TP/TN/FP/FN。默认为 True，将以指标名称为键保存到 engine.state.metric_details 字典中。

另请参阅

monai.metrics.wrapper()

指标记录器#

class monai.handlers.MetricLogger(loss_transform=<function _get_loss_from_output>, metric_transform=<function MetricLogger.<lambda>>, evaluator=None)[source]#

从附加的训练器中收集每次迭代的指标和损失值。它还将从给定的评估器对象收集指标值，该评估器对象预计在训练 epoch 结束时执行评估。此类对于将损失和指标值收集到一处以便与检查点保存器一起存储（提供 PyTorch 和 Ignite 所期望的 state_dict 和 load_state_dict 方法）以及在训练期间进行绘图非常有用。

示例：

# construct an evaluator saving mean dice metric values in the key “val_mean_dice” evaluator = SupervisedEvaluator(…, key_val_metric={“val_mean_dice”: MeanDice(…)})

# construct the logger and associate with evaluator to extract metric values from logger = MetricLogger(evaluator=evaluator)

# construct the trainer with the logger passed in as a handler so that it logs loss values trainer = SupervisedTrainer(…, train_handlers=[logger, ValidationHandler(1, evaluator)])

# run training, logger.loss will be a list of (iteration, loss) values, logger.metrics a dict with key # “val_mean_dice” storing a list of (iteration, metric) values trainer.run()

参数:

  • loss_transform – 将训练器状态中的 output 值转换为损失值。engine.state 和 loss_transform 继承自 ignite 概念：https://pytorch.ac.cn/ignite/concepts.html#state，说明和使用示例可在教程中找到：Project-MONAI/tutorials。

  • metric_transform – 将来自训练器/评估器状态的指标值转换为可存储的值

  • evaluator – 可选的评估器，用于在其评估运行结束时从中获取指标结果

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

attach_evaluator(evaluator)[source]#

将事件处理程序附加到给定的评估器，以从中记录指标值。

参数:

evaluator (Engine) – 实现网络评估的 Ignite 引擎

返回类型:

None

log_metrics(engine)[source]#

记录来自给定引擎状态成员的指标。

参数:

engine (Engine) – 用于记录的 Ignite 引擎

返回类型:

None

日志文件处理程序#

class monai.handlers.LogfileHandler(output_dir, filename='log.txt', loglevel=20, formatter='%(asctime)s %(name)s %(levelname)s: %(message)s', create_dir=True)[source]#

在启动事件发生时向附加引擎的记录器添加一个 logging.FileHandler，并在完成事件发生时再次将其移除。

需要在完成事件发生时移除 FileHandler 对象，以便不同引擎的后续运行只写入它们应写入的日志文件，而不是之前的文件。多个处理程序可以写入同一个文件，这使得训练和评估引擎对象的输出可以集中在一个文件中。如果给定的输出目录不存在，默认情况下会在启动事件发生时创建。这可以与 CheckpointSaver 结合使用，将日志文件保存到与保存的检查点相同的目标位置。由于处理程序可能在初始化期间的其他日志记录事件之后添加，因此并非所有日志记录数据都会被保留。

参数:

  • output_dir (str) – 保存日志文件的目录

  • filename (str) – 保存日志的文件名

  • loglevel (int) – 处理程序的日志级别

  • formatter (str) – 为处理程序设置的 logging.Formatter 的格式字符串

  • create_dir (bool) – 如果为 True，则在 output_dir 不存在时创建它

训练统计信息处理程序#

class monai.handlers.StatsHandler(iteration_log=True, epoch_log=True, epoch_print_logger=None, iteration_print_logger=None, output_transform=<function StatsHandler.<lambda>>, global_epoch_transform=<function StatsHandler.<lambda>>, state_attributes=None, name='StatsHandler', tag_name='Loss', key_var_format='{}: {:.4f} ')[source]#

StatsHandler 定义了一组用于所有日志打印逻辑的 Ignite 事件处理器。它可用于任何 Ignite Engine（训练器、验证器和评估器）。它支持使用预定义记录器进行 epoch 级别和迭代级别的日志记录。

请注意，如果 name 为 None，则此类将使用 engine.logger 作为记录器，否则将使用 logging.getLogger(name)。在这两种情况下，确保日志记录级别至少为 INFO 非常重要。要更改日志记录级别，请在运行附加此处理器的引擎之前调用 import ignite; ignite.utils.setup_logger(name)（当 name 不为 None 时）或 engine.logger = ignite.utils.setup_logger(engine.logger.name, reset=True)（当 name 为 None 时）。

默认行为

  • EPOCH_COMPLETED 时，使用 self.logger 记录 engine.state.metrics。

  • ITERATION_COMPLETED 时，使用 self.logger 记录 self.output_transform(engine.state.output)。

使用示例

import ignite
import monai

trainer = ignite.engine.Engine(lambda x, y: [0.0])  # an example trainer
monai.handlers.StatsHandler(name="train_stats").attach(trainer)

trainer.run(range(3), max_epochs=4)

更多示例细节可在教程中找到： Project-MONAI/tutorials。

__init__(iteration_log=True, epoch_log=True, epoch_print_logger=None, iteration_print_logger=None, output_transform=<function StatsHandler.<lambda>>, global_epoch_transform=<function StatsHandler.<lambda>>, state_attributes=None, name='StatsHandler', tag_name='Loss', key_var_format='{}: {:.4f} ')[source]#
参数:

  • iteration_log – 是否在迭代完成时记录数据，默认为 True。iteration_log 也可以是一个函数，它将被解释为事件过滤器（详见 https://pytorch.ac.cn/ignite/generated/ignite.engine.events.Events.html）。事件过滤器函数接受引擎和事件值（迭代次数）作为输入，并应返回 True/False。事件过滤有助于定制迭代日志记录频率。

  • epoch_log – 是否在 epoch 完成时记录数据，默认为 True。epoch_log 也可以是一个函数，它将被解释为事件过滤器。详见 iteration_log 参数。

  • epoch_print_logger – 用于 epoch 级别日志记录的自定义可调用打印器。必须接受参数 “engine”，如果为 None 则使用默认打印器。

  • iteration_print_logger – 用于迭代级别日志记录的自定义可调用打印器。必须接受参数 “engine”，如果为 None 则使用默认打印器。

  • output_transform – 一个可调用对象，用于将 ignite.engine.state.output 转换为要打印的标量，或 {key: scalar} 字典。在后一种情况下，输出字符串将格式化为 key: value。默认情况下，此值日志记录在每次迭代完成时发生。默认行为是打印 output[0] 中的损失，因为 output 是一个解批处理列表，我们将损失值复制到解批处理列表的每个项。 engine.state 和 output_transform 继承自 ignite 概念： https://pytorch.ac.cn/ignite/concepts.html#state，解释和使用示例可在教程中找到： Project-MONAI/tutorials。

  • global_epoch_transform – 一个可调用对象，用于自定义全局 epoch 数。例如，在评估中，评估器引擎可能希望打印与训练器引擎同步的 epoch 数。

  • state_attributes – engine.state 中预期的属性，如果提供，将在 epoch 完成时提取它们。

  • name – 要使用的 logging.logger 的标识符，如果为 None，则默认为 engine.logger。

  • tag_name – 当迭代输出是标量时，tag_name 用于打印 tag_name: scalar_value 到记录器。默认为 'Loss'。

  • key_var_format – 控制 key: value 输出字符串格式的格式化字符串。

attach(engine)[source]#

注册一组 Ignite 事件处理器到指定的 Ignite engine。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

epoch_completed(engine)[source]#

训练或验证/评估 epoch 完成事件的处理器。打印 epoch 级别日志，默认值来自 Ignite engine.state.metrics 字典。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

exception_raised(_engine, e)[source]#

训练或验证/评估异常抛出事件的处理器。打印异常信息和堆栈跟踪。由于 Ignite 的逻辑只能触发 EXCEPTION_RAISED 事件的第一个附加处理器，此回调可能会被跳过。

参数:

  • _engine (Engine) – Ignite Engine，未使用参数。

  • e (Exception) – 在 Ignite 引擎运行期间捕获的异常。

返回类型:

None

iteration_completed(engine)[source]#

训练或验证/评估迭代完成事件的处理器。打印迭代级别日志，默认值来自 Ignite engine.state.output。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

Tensorboard handlers#

class monai.handlers.TensorBoardHandler(summary_writer=None, log_dir='./runs')[source]#

用于将数据写入 TensorBoard 的处理器的基类。

参数:

  • summary_writer – 用户可以指定 TensorBoard 或 TensorBoardX SummaryWriter，默认为创建一个新的 TensorBoard writer。

  • log_dir – 如果使用默认的 SummaryWriter，则将日志写入此目录，默认为 ./runs。

close()[source]#

如果在 TensorBoard handler 中创建了 summary writer，则关闭它。

class monai.handlers.TensorBoardStatsHandler(summary_writer=None, log_dir='./runs', iteration_log=True, epoch_log=True, epoch_event_writer=None, iteration_event_writer=None, output_transform=<function TensorBoardStatsHandler.<lambda>>, global_epoch_transform=<function TensorBoardStatsHandler.<lambda>>, state_attributes=None, tag_name='Loss')[source]#

TensorBoardStatsHandler 定义了一组用于所有 TensorBoard 逻辑的 Ignite 事件处理器。它可用于任何 Ignite Engine（训练器、验证器和评估器）。它支持使用预定义的 TensorBoard 事件写入器进行 epoch 级别和迭代级别的日志记录。预期的数据源是 Ignite engine.state.output 和 engine.state.metrics。

默认行为

  • EPOCH_COMPLETED 时，将 engine.state.metrics 中的每个字典项写入 TensorBoard。

  • ITERATION_COMPLETED 时，将 self.output_transform(engine.state.output) 中的每个字典项写入 TensorBoard。

使用示例可在教程中找到： Project-MONAI/tutorials。

__init__(summary_writer=None, log_dir='./runs', iteration_log=True, epoch_log=True, epoch_event_writer=None, iteration_event_writer=None, output_transform=<function TensorBoardStatsHandler.<lambda>>, global_epoch_transform=<function TensorBoardStatsHandler.<lambda>>, state_attributes=None, tag_name='Loss')[source]#
参数:

  • summary_writer – 用户可以指定 TensorBoard 或 TensorBoardX SummaryWriter，默认为创建一个新的 TensorBoard writer。

  • log_dir – 如果使用默认的 SummaryWriter，则将日志写入此目录，默认为 ./runs。

  • iteration_log – 是否在迭代完成时将数据写入 TensorBoard，默认为 True。iteration_log 也可以是函数或整数。如果是整数，则将其解释为调用 iteration_event_writer 的迭代间隔。如果是函数，则将其解释为事件过滤器（详见 https://pytorch.ac.cn/ignite/generated/ignite.engine.events.Events.html）。事件过滤器函数接受引擎和事件值（迭代次数）作为输入，并应返回 True/False。

  • epoch_log – 是否在 epoch 完成时将数据写入 TensorBoard，默认为 True。epoch_log 也可以是函数或整数。如果是整数，则将其解释为调用 epoch_event_writer 的 epoch 间隔。如果是函数，则将其解释为事件过滤器。详见 iteration_log 参数。

  • epoch_event_writer – 用于 epoch 级别的自定义可调用 TensorBoard writer。必须接受参数 “engine” 和 “summary_writer”，如果为 None 则使用默认事件写入器。

  • iteration_event_writer – 用于迭代级别的自定义可调用 TensorBoard writer。必须接受参数 “engine” 和 “summary_writer”，如果为 None 则使用默认事件写入器。

  • output_transform – 一个可调用对象，用于将 ignite.engine.state.output 转换为要绘制的标量，或 {key: scalar} 字典。在后一种情况下，输出字符串将格式化为 key: value。默认情况下，此值绘制在每次迭代完成时发生。默认行为是绘制 output[0] 中的损失，因为 output 是一个解批处理列表，我们将损失值复制到解批处理列表的每个项。 engine.state 和 output_transform 继承自 ignite 概念： https://pytorch.ac.cn/ignite/concepts.html#state，解释和使用示例可在教程中找到： Project-MONAI/tutorials。

  • global_epoch_transform – 一个可调用对象，用于自定义全局 epoch 数。例如，在评估中，评估器引擎可能希望在绘制 epoch vs metric 曲线时使用训练器引擎的 epoch 数。

  • state_attributes – engine.state 中预期的属性，如果提供，将在 epoch 完成时提取它们。

  • tag_name – 当迭代输出是标量时，tag_name 用于绘制，默认为 'Loss'。

attach(engine)[source]#

注册一组 Ignite 事件处理器到指定的 Ignite engine。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

epoch_completed(engine)[source]#

训练或验证/评估 epoch 完成事件的处理器。写入 epoch 级别事件，默认值来自 Ignite engine.state.metrics 字典。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

iteration_completed(engine)[source]#

训练或验证/评估迭代完成事件的处理器。写入迭代级别事件，默认值来自 Ignite engine.state.output。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

class monai.handlers.TensorBoardImageHandler(summary_writer=None, log_dir='./runs', interval=1, epoch_level=True, batch_transform=<function TensorBoardImageHandler.<lambda>>, output_transform=<function TensorBoardImageHandler.<lambda>>, global_iter_transform=<function TensorBoardImageHandler.<lambda>>, index=0, max_channels=1, frame_dim=-3, max_frames=64)[source]#

TensorBoardImageHandler 是一个 Ignite 事件处理器，可以将图像、标签和输出可视化为 2D/3D 图像。2D 输出（形状为 Batch, channel, H, W）将使用批次中的第一个元素作为简单图像显示；对于 3D 到 ND 输出（形状为 Batch, channel, H, W, D），self.max_channels 个图像的后三个维度将沿最后一个轴（通常是 Depth）显示为动画 GIF。如果 writer 来自 TensorBoardX，数据有 3 个通道且 max_channels=3，则将绘制为 RGB 视频。

它可用于任何 Ignite Engine（训练器、验证器和评估器）。用户可以轻松地将其添加到引擎中以处理任何预期的事件，例如：EPOCH_COMPLETED，ITERATION_COMPLETED。预期的数据源是 ignite 的 engine.state.batch 和 engine.state.output。

默认行为

  • 在触发事件时，在 TensorBoard 上将 y_pred 显示为图像（3D 为 GIF），

  • 需要使用 batch_transform 和 output_transform 来指定显示多少图像以及显示哪个通道。

  • 期望 batch_transform(engine.state.batch) 返回数据格式：(image[N, channel, …], label[N, channel, …])。

  • 期望 output_transform(engine.state.output) 返回格式为 (y_pred[N, channel, …], loss) 的 torch tensor。

使用示例可在教程中找到： Project-MONAI/tutorials。

__init__(summary_writer=None, log_dir='./runs', interval=1, epoch_level=True, batch_transform=<function TensorBoardImageHandler.<lambda>>, output_transform=<function TensorBoardImageHandler.<lambda>>, global_iter_transform=<function TensorBoardImageHandler.<lambda>>, index=0, max_channels=1, frame_dim=-3, max_frames=64)[source]#
参数:

  • summary_writer – 用户可以指定 TensorBoard 或 TensorBoardX SummaryWriter，默认为创建一个新的 TensorBoard writer。

  • log_dir – 如果使用默认的 SummaryWriter，则将日志写入此目录，默认为 ./runs。

  • interval – 每 N 个 epoch 或每 N 次迭代绘制一次 engine.state 中的内容，默认为 1。

  • epoch_level – 每 N 个 epoch 或 N 次迭代绘制 engine.state 中的内容。True 表示 epoch 级别，False 表示迭代级别。

  • batch_transform – 一个可调用对象，用于从 ignite.engine.state.batch 中提取 image 和 label，然后构建 (image, label) 对。例如：如果 ignite.engine.state.batch 是 {“image”: xxx, “label”: xxx, “other”: xxx}，则 batch_transform 可以是 lambda x: (x[“image”], x[“label”])。将使用结果绘制来自 result[0][index] 的图像，并绘制来自 result[1][index] 的标签。 engine.state 和 batch_transform 继承自 ignite 概念： https://pytorch.ac.cn/ignite/concepts.html#state，解释和使用示例可在教程中找到： Project-MONAI/tutorials。

  • output_transform – 一个可调用对象，用于从 ignite.engine.state.output 中提取 predictions 数据，将使用结果绘制来自 result[index] 的输出。 engine.state 和 output_transform 继承自 ignite 概念： https://pytorch.ac.cn/ignite/concepts.html#state，解释和使用示例可在教程中找到： Project-MONAI/tutorials。

  • global_iter_transform – 一个可调用对象，用于自定义 TensorBoard 的全局步数。例如，在评估中，评估器引擎需要知道训练器当前的 epoch 数。

  • index – 绘制数据批次中的哪个元素，默认为第一个元素。

  • max_channels – 要绘制的通道数。

  • frame_dim – 如果将 3D 图像绘制为 GIF，请指定用作帧的维度，预期输入数据形状为 NCHWD，默认为 -3（第一个空间维度）。

  • max_frames – 如果在 TensorBoardX 中将 3D RGB 图像绘制为视频，则将 FPS 设置为 max_frames。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

LR Schedule handler#

class monai.handlers.LrScheduleHandler(lr_scheduler, print_lr=True, name=None, epoch_level=True, step_transform=<function LrScheduleHandler.<lambda>>)[source]#

基于 PyTorch LR scheduler 更新学习率的 Ignite handler。

__init__(lr_scheduler, print_lr=True, name=None, epoch_level=True, step_transform=<function LrScheduleHandler.<lambda>>)[source]#
参数:

  • lr_scheduler – 通常，lr_scheduler 应该是 PyTorch 的 lr_scheduler 对象。如果是自定义版本，必须有 step 和 get_last_lr 方法。

  • print_lr – 是否通过日志打印最新的学习率。

  • name – 要使用的 logging.logger 的标识符，如果为 None，则默认为 engine.logger。

  • epoch_level – 是在每个 epoch 后还是每次迭代后执行 lr_scheduler.step()。True 表示 epoch 级别，False 表示迭代级别。

  • step_transform – 如果有必要，一个可调用对象用于将来自 engine 的信息转换为 lr_scheduler.step() 函数的预期输入数据。

抛出:

TypeError – 当 step_transform 不可调用时。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

Validation handler#

class monai.handlers.ValidationHandler(interval, validator=None, epoch_level=True, exec_at_start=False)[source]#

将 validator 附加到 Ignite 中的 trainer engine。它支持每 N 个 epoch 或每 N 次迭代执行一次验证。

__init__(interval, validator=None, epoch_level=True, exec_at_start=False)[source]#
参数:

  • interval – 在训练期间每 N 个 epoch 或每 N 次迭代进行验证。

  • validator – 触发验证时运行 validator，应为 Evaluator。如果为 None，则在训练前应调用 set_validator()。

  • epoch_level – 每 N 个 epoch 或 N 次迭代执行验证。True 表示 epoch 级别，False 表示迭代级别。

  • exec_at_start – 是否在开始训练时首先执行一次验证。默认为 False。这在某些迁移学习情况下特别有用，可以在训练前验证初始模型。

抛出:

TypeError – 当 validator 不是 monai.engines.evaluator.Evaluator 时。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

set_validator(validator)[source]#

如果在 __init__() 中未设置，则设置 validator。

返回类型:

None

SmartCache handler#

class monai.handlers.SmartCacheHandler(smartcacher)[source]#

将 SmartCache 逻辑附加到 Ignite 中的 engine。主要包括 SmartCacheDataset 的 start、update_cache 和 shutdown 函数。

__init__(smartcacher)[source]#
参数:

smartcacher (SmartCacheDataset) – 预定义的 SmartCacheDataset，将将其附加到 engine。

抛出:

TypeError – 当 smartcacher 不是 monai.data.SmartCacheDataset 时。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

completed(engine)[source]#

训练或验证/评估完成事件的回调。停止 SmartCacheDataset 的替换线程。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

epoch_completed(engine)[source]#

训练或验证/评估 epoch 完成事件的回调。使用替换数据更新缓存内容。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

started(engine)[source]#

训练或验证/评估开始事件的回调。启动 SmartCacheDataset 的替换线程。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

Parameter Scheduler handler#

class monai.handlers.ParamSchedulerHandler(parameter_setter, value_calculator, vc_kwargs, epoch_level=False, name=None, event=None)[source]#

用于参数值的通用 scheduler。默认情况下，它支持线性、指数、步长或多步长函数调度。也可以传递可调用对象以实现自定义调度逻辑。

参数:

  • parameter_setter (Callable) – 设置所需参数的函数

  • value_calculator (Union[str,Callable]) – 字符串（‘linear’, ‘exponential’, ‘step’ 或 ‘multistep’）或用于自定义逻辑的可调用对象。

  • vc_kwargs (Dict) – 存储 value_calculator 所需参数的字典。

  • epoch_level (bool) – 步长是否基于 epoch 或迭代。默认为 False。

  • name (Optional[str]) – 要使用的 logging.logger 的标识符，如果为 None，则默认为 engine.logger。

  • event (Optional[str]) – handler 附加到的事件。默认为 Events.ITERATION_COMPLETED。

attach(engine)[source]#
参数:

engine (Engine) – 用于训练的 Ignite Engine。

返回类型:

None

EarlyStop handler#

class monai.handlers.EarlyStopHandler(patience, score_function, trainer=None, min_delta=0.0, cumulative_delta=False, epoch_level=True)[source]#

EarlyStopHandler 作为 Ignite handler，如果在给定事件次数后没有改进，则停止训练。它基于 ignite 中的 EarlyStopping handler。

参数:

  • patience – 在没有改进的情况下等待的事件次数，然后停止训练。

  • score_function – 它应该是一个接受单个参数（handler 附加到的 Engine 对象，可以是 trainer 或 validator）并返回 float 分数的函数。如果分数更高，则认为有改进。

  • trainer – 如果没有改进，用于停止运行的 trainer engine，如果为 None，则必须在训练前调用 set_trainer()。

  • min_delta – 判定为改进所需的最小分数增量，即小于或等于 min_delta 的增量将视为没有改进。

  • cumulative_delta – 如果为 True，min_delta 定义的是自上次 patience 重置以来的总增量，否则定义的是自上次事件以来的增量，默认为 False。

  • epoch_level – 检查附加引擎的每个 epoch 或每次迭代是否需要提前停止，True 表示 epoch 级别，False 表示迭代级别，默认为 epoch 级别。

注意

如果在分布式训练中，并使用每次迭代的 loss 值来检测提前停止，则不同 rank 的值可能不同。在使用此 handler 进行分布式训练时，请注意为了防止“dist.destroy_process_group()”挂起，您可以使用“all_reduce”操作来同步所有 rank 的停止信号。该机制可以在 score_function 中实现。以下是一个示例：

import os

import torch
import torch.distributed as dist


def score_function(engine):
    val_metric = engine.state.metrics["val_mean_dice"]
    if dist.is_initialized():
        device = torch.device("cuda:" + os.environ["LOCAL_RANK"])
        val_metric = torch.tensor([val_metric]).to(device)
        dist.all_reduce(val_metric, op=dist.ReduceOp.SUM)
        val_metric /= dist.get_world_size()
        return val_metric.item()
    return val_metric

用户可以将此 handler 附加到 validator engine 以检测验证指标并停止训练，在这种情况下，score_function 在 validator engine 上执行，而 trainer 是 trainer engine。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

set_trainer(trainer)[source]#

如果在 __init__() 中未正确设置，则设置 trainer 以执行提前停止。

返回类型:

None

GarbageCollector handler#

class monai.handlers.GarbageCollector(trigger_event='epoch', log_level=10)[source]#

在每个 epoch 后运行垃圾收集器

参数:

  • trigger_event – 触发此 handler 调用的事件。- “epoch”，在每个 epoch 完成后（等同于 ignite.engine.Events.EPOCH_COMPLETED）- “iteration”，在每次迭代完成后（等同于 ignite.engine.Events.ITERATION_COMPLETED）- ignite.engine.Events 中的任何内置 ignite 事件。默认为 “epoch”。

  • log_level – 用于以下一些垃圾收集信息的日志级别（整数）。默认为 10 (DEBUG)。- 50 (CRITICAL) - 40 (ERROR) - 30 (WARNING) - 20 (INFO) - 10 (DEBUG) - 0 (NOTSET)

Post processing#

class monai.handlers.PostProcessing(transform, event='MODEL_COMPLETED')[source]#

Ignite handler，用于在 engine 中的后处理之后执行额外的后处理。因此，用户可以在 engine 的后处理和此后处理 handler 之间插入其他 handler。如果使用来自 monai.transforms 的组件作为 transform，建议先在 engine 中（设置 decollate=True）或在 DecollateBatch handler 中解批处理 engine.state.batch 和 engine.state.output。

__init__(transform, event='MODEL_COMPLETED')[source]#
参数:

  • transform (Callable) – 在 engine.state.batch 和 engine.state.output 上执行的可调用函数。也可以是组合的 transforms。

  • event (str) – 预期附加 handler 的事件，应为 “MODEL_COMPLETED” 或 “ITERATION_COMPLETED”。默认为 “MODEL_COMPLETED”。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

Decollate batch#

class monai.handlers.DecollateBatch(event='MODEL_COMPLETED', detach=True, decollate_batch=True, batch_keys=None, decollate_output=True, output_keys=None, allow_missing_keys=False)[source]#

Ignite handler，用于对 engine.state.batch 和 engine.state.output 执行 decollate batch 逻辑。典型用法是在 engine 中设置 decollate=False，先执行一些后处理逻辑，然后再解批处理，否则 engine 将在后处理之前解批处理。

参数:

  • event – 预期附加 handler 的事件，应为 “MODEL_COMPLETED” 或 “ITERATION_COMPLETED”。默认为 “MODEL_COMPLETED”。

  • detach – 是否分离 tensors。标量 tensors 将分离为数字类型而非 torch tensors。

  • decollate_batch – 是否解批处理 ignite engine 的 engine.state.batch。

  • batch_keys – 如果 decollate_batch=True，指定 engine.state.batch 中要解批处理的相应项的键，注意它会删除未指定的其他键。如果为 None，则解批处理所有键。它将标量值复制到解批处理列表的每个项。

  • decollate_output – 是否解批处理 ignite engine 的 engine.state.output。

  • output_keys – 如果 decollate_output=True，指定 engine.state.output 中要解批处理的相应项的键，注意它会删除未指定的其他键。如果为 None，则解批处理所有键。它将标量值复制到解批处理列表的每个项。

  • allow_missing_keys – 如果键缺失，则不抛出异常。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

MLFlow handler#

class monai.handlers.MLFlowHandler(tracking_uri=None, iteration_log=True, epoch_log=True, epoch_logger=None, iteration_logger=None, dataset_logger=None, dataset_dict=None, dataset_keys=image, output_transform=<function MLFlowHandler.<lambda>>, global_epoch_transform=<function MLFlowHandler.<lambda>>, state_attributes=None, tag_name='Loss', experiment_name='monai_experiment', run_name=None, experiment_param=None, artifacts=None, optimizer_param_names='lr', close_on_complete=False)[source]#

MLFlowHandler 定义了一组用于 MLFlow 跟踪逻辑的 Ignite 事件处理器。它可用于任何 Ignite Engine（训练器、验证器和评估器）。它可以跟踪 epoch 级别和迭代级别的日志记录，然后 MLFlow 可以存储数据并可视化。预期的数据源是 Ignite engine.state.output 和 engine.state.metrics。

默认行为

  • EPOCH_COMPLETED 时，在 MLFlow 中跟踪 engine.state.metrics 中的每个字典项。

  • ITERATION_COMPLETED 时，在 MLFlow 中跟踪 self.output_transform(engine.state.output) 中预期的项，默认为 Loss。

使用示例可在教程中找到： Project-MONAI/tutorials。

参数:

  • tracking_uri – 连接到跟踪 URI。也可以设置 MLFLOW_TRACKING_URI 环境变量，让 MLflow 从那里找到 URI。在这两种情况下，URI 可以是远程服务器的 HTTP/HTTPS URI、数据库连接字符串，或者将数据记录到目录的本地路径。URI 默认为路径 mlruns。更多详情请参见：https://mlflow.org/docs/latest/python_api/mlflow.html#mlflow.set_tracking_uri。

  • iteration_log – 是否在迭代完成时将数据记录到 MLFlow，默认为 True。iteration_log 也可以是函数，它将被解释为事件过滤器（详见 https://pytorch.ac.cn/ignite/generated/ignite.engine.events.Events.html）。事件过滤器函数接受引擎和事件值（迭代次数）作为输入，并应返回 True/False。

  • epoch_log – 是否在 epoch 完成时将数据记录到 MLFlow，默认为 True。epoch_log 也可以是函数，它将被解释为事件过滤器。详见 iteration_log 参数。

  • epoch_logger – 用于 epoch 级别 MLFlow 日志记录的自定义可调用 logger。必须接受参数 “engine”，如果为 None 则使用默认 logger。

  • iteration_logger – 用于迭代级别 MLFlow 日志记录的自定义可调用 logger。必须接受参数 “engine”，如果为 None 则使用默认 logger。

  • dataset_logger – 用于使用 MLFlow 记录数据集信息的自定义可调用 logger。必须接受参数 “dataset_dict”，如果为 None 则使用默认 logger。

  • dataset_dict – 需要记录的数据集的字典，其中键是数据集的名称，值是 PyTorch 数据集。此参数仅在 MLFlow 版本 >= 2.4.0 时有用。关于如何使用 MLFlow 记录数据的更多详情，请访问网站：https://mlflow.org/docs/latest/python_api/mlflow.data.html。

  • dataset_keys – 一个或多个键，指示数据集中需要由 MLFlow 存储的内容。

  • output_transform – 一个可调用对象，用于将 ignite.engine.state.output 转换为要跟踪的标量，或 {key: scalar} 字典。默认情况下，此值日志记录在每次迭代完成时发生。默认行为是跟踪 output[0] 中的损失，因为 output 是一个解批处理列表，我们将损失值复制到解批处理列表的每个项。 engine.state 和 output_transform 继承自 ignite 概念： https://pytorch-ignite.ai/concepts/03-state/，解释和使用示例可在教程中找到： Project-MONAI/tutorials。

  • global_epoch_transform – 一个可调用对象，用于自定义全局 epoch 数。例如，在评估中，评估器引擎可能希望跟踪与训练器引擎同步的 epoch 数。

  • state_attributes – engine.state 中预期的属性，如果提供，将在 epoch 完成时提取它们。

  • tag_name – 当迭代输出是标量时，使用 tag_name 进行跟踪，默认为 ‘Loss’。

  • experiment_name – MLflow 的实验名称，默认为 ‘monai_experiment’。一个实验可以记录多次运行。

  • run_name – 实验中的运行名称。运行可以记录关于工作流的信息，如损失、指标等。

  • experiment_param – 一个字典，记录在整个工作流中不会改变的参数，如 torch 版本、cuda 版本等。

  • artifacts – 工作流运行后需要记录的图像路径。

  • optimizer_param_names – 在工作流运行期间需要记录的优化器中的参数名称，默认为 ‘lr’。

  • close_on_complete – 是否在工作流的 complete 阶段关闭 mlflow 运行，默认为 False。

更多 MLFlow 用法详情，请参考：https://mlflow.org/docs/latest/index.html。

attach(engine)[source]#

注册一组 Ignite 事件处理器到指定的 Ignite engine。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

close()[source]#

停止 MLFlow 当前正在运行的 logger。

返回类型:

None

complete()[source]#

训练或验证/评估完成事件的 handler。

返回类型:

None

epoch_completed(engine)[source]#

训练或验证/评估 epoch 完成事件的 handler。跟踪 epoch 级别日志，默认值来自 Ignite engine.state.metrics 字典。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

iteration_completed(engine)[source]#

训练或验证/评估迭代完成事件的 handler。跟踪迭代级别日志。

参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

start(engine)[source]#

检查 MLFlow 状态，如果未激活则启动。

返回类型:

None

ClearML handlers#

class monai.handlers.ClearMLHandler(project_name, task_name, output_uri, tags, reuse_last_task_id, continue_last_task, auto_connect_frameworks, auto_connect_arg_parser)[source]#

用于将所有内容记录到 ClearML 的 handler 的基类。关于 ClearML 用法的更多详情，请参考：https://clear.ml/docs/latest/docs/references/sdk/task

使用示例可在教程中找到： Project-MONAI/tutorials。

__init__(project_name, task_name, output_uri, tags, reuse_last_task_id, continue_last_task, auto_connect_frameworks, auto_connect_arg_parser)[source]#
参数:

  • project_name – ClearML 项目名称，默认为 ‘MONAI’。

  • task_name – ClearML 任务名称，默认为 ‘monai_experiment’。

  • output_uri – 输出模型和其他 artifact 的默认位置，默认为 ‘True’。

  • tags – 向创建的任务添加标签列表 (str)，默认为 ‘None’。

  • reuse_last_task_id – 强制使用先前使用的 Task ID 创建新任务（实验），默认为 ‘True’。

  • continue_last_task – 继续执行先前执行的任务（实验），默认为 ‘False’。

  • auto_connect_frameworks – 自动连接框架，默认为 ‘True’。

  • auto_connect_arg_parser – 自动将 argparse 对象连接到 Task，默认为 ‘True’。

class monai.handlers.ClearMLStatsHandler(project_name='MONAI', task_name='monai_experiment', output_uri=True, tags=None, reuse_last_task_id=True, continue_last_task=False, auto_connect_frameworks=True, auto_connect_arg_parser=True, *args, **kwargs)[source]#

通过继承 TensorBoardStatsHandler 类来写入 tensorboard 统计信息的类。Tensorboard 中的所有内容都会自动记录到 ClearML。

使用示例可在教程中找到： Project-MONAI/tutorials。

__init__(project_name='MONAI', task_name='monai_experiment', output_uri=True, tags=None, reuse_last_task_id=True, continue_last_task=False, auto_connect_frameworks=True, auto_connect_arg_parser=True, *args, **kwargs)[source]#
参数:

  • project_name – ClearML 项目名称，默认为 ‘MONAI’。

  • task_name – ClearML 任务名称，默认为 ‘monai_experiment’。

  • output_uri – 输出模型和其他 artifact 的默认位置，默认为 ‘True’。

  • tags – 向创建的任务添加标签列表 (str)，默认为 ‘None’。

  • reuse_last_task_id – 强制使用先前使用的 Task ID 创建新任务（实验），默认为 ‘True’。

  • continue_last_task – 继续执行先前执行的任务（实验），默认为 ‘False’。

  • auto_connect_frameworks – 自动连接框架，默认为 ‘True’。

  • auto_connect_arg_parser – 自动将 argparse 对象连接到 Task，默认为 ‘True’。

class monai.handlers.ClearMLImageHandler(project_name='MONAI', task_name='monai_experiment', output_uri=True, tags=None, reuse_last_task_id=True, continue_last_task=False, auto_connect_frameworks=True, auto_connect_arg_parser=True, *args, **kwargs)[source]#

此类继承了 TensorBoardImageHandler 类的所有功能。Tensorboard 中的所有内容都会自动记录到 ClearML。

使用示例可在教程中找到： Project-MONAI/tutorials。

__init__(project_name='MONAI', task_name='monai_experiment', output_uri=True, tags=None, reuse_last_task_id=True, continue_last_task=False, auto_connect_frameworks=True, auto_connect_arg_parser=True, *args, **kwargs)[source]#
参数:

  • project_name – ClearML 项目名称，默认为 ‘MONAI’。

  • task_name – ClearML 任务名称，默认为 ‘monai_experiment’。

  • output_uri – 输出模型和其他 artifact 的默认位置，默认为 ‘True’。

  • tags – 向创建的任务添加标签列表 (str)，默认为 ‘None’。

  • reuse_last_task_id – 强制使用先前使用的 Task ID 创建新任务（实验），默认为 ‘True’。

  • continue_last_task – 继续执行先前执行的任务（实验），默认为 ‘False’。

  • auto_connect_frameworks – 自动连接框架，默认为 ‘True’。

  • auto_connect_arg_parser – 自动将 argparse 对象连接到 Task，默认为 ‘True’。

NVTX Handlers#

用于对 MONAI ignite 工作流进行性能分析的 NVIDIA 工具扩展的封装

class monai.handlers.nvtx_handlers.MarkHandler(event, msg=None)[source]#

标记在某个时间点发生的瞬时事件。

参数:

msg – 与范围相关联的 ASCII 消息

attach(engine)[source]#

将 NVTX 标记添加到特定的 Ignite 事件 :type engine: Engine :param engine: Ignite Engine，可以是 trainer、validator 或 evaluator。

返回类型:

None

class monai.handlers.nvtx_handlers.RangeHandler(events, msg=None)[source]#

将 NVTX 范围附加到一对 Ignite 事件。它在第一个事件处推送 NVTX 范围，并在第二个事件处弹出。存储已开始的范围的零基深度。

参数:

  • events – 一个字符串、一对 Ignite 事件、一对 Ignite 事件字面量或一对 Ignite 事件和字面量。如果提供单个字符串，它应该描述一对带有 _STARTED 和 _COMPLETED 后缀的默认 Ignite 事件的基本名称（例如，Events.EPOCH_STARTED 和 Events.EPOCH_COMPLETED 的 “EPOCH”）。接受的事件包括：BATCH、ITERATION、EPOCH 和 ENGINE。如果是字面量对，每个字面量都应该是 Ignite 事件的等价字面量，例如：(“EPOCH_STARTED” 和 “EPOCH_COMPLETED”)。可以将事件和字面量组合使用，例如 (Events.EPOCH_STARTED 和 “EPOCH_COMPLETED”)。有关事件的完整列表，请查看 https://pytorch.ac.cn/ignite/generated/ignite.engine.events.Events.html。

  • msg – 与范围相关联的 ASCII 消息。如果未提供，第一个事件的名称将分配给 NVTX 范围。

attach(engine)[source]#

将 NVTX 范围附加到特定的 Ignite 事件 :type engine: Engine :param engine: Ignite Engine，可以是 trainer、validator 或 evaluator。

返回类型:

None

create_paired_events(event)[source]#

根据事件前缀名称创建一对 Ignite 事件

返回类型:

tuple[Events, Events]

resolve_events(events)[source]#

解析输入事件以创建一对 Ignite 事件

class monai.handlers.nvtx_handlers.RangePopHandler(event)[source]#

在特定事件处，弹出一个先前推送的范围。存储已开始的范围的零基深度。

参数:

msg – 与范围相关联的 ASCII 消息

attach(engine)[source]#

在特定的 Ignite 事件处弹出一个 NVTX 范围 :type engine: Engine :param engine: Ignite Engine，可以是 trainer、validator 或 evaluator。

返回类型:

None

class monai.handlers.nvtx_handlers.RangePushHandler(event, msg=None)[source]#

在特定事件处，将一个范围推送到嵌套范围跨度堆栈上。存储已开始的范围的零基深度。

参数:

msg – 与范围相关联的 ASCII 消息

attach(engine)[source]#

在特定的 Ignite 事件处推送一个 NVTX 范围 :type engine: Engine :param engine: Ignite Engine，可以是 trainer、validator 或 evaluator。

返回类型:

None

Utilities#

monai.handlers.utils.from_engine(keys, first=False)[source]#

实用函数，用于处理字典或字典列表（例如：`engine.state.batch` 或 `engine.state.output`）时简化 ignite 组件的 `batch_transform` 或 `output_transform` 参数。用户只需设置期望的键，然后它将返回一个可调用函数，用于从字典中提取数据并分别构造一个元组。

如果解批处理后数据是字典列表，则分别提取期望的键并构造列表，例如，如果数据是 `[{“A”: 1, “B”: 2}, {“A”: 3, “B”: 4}]`，from_engine([“A”, “B”]) 将得到 `([1, 3], [2, 4])`。

这有助于避免复杂的 `lambda` 函数，并使指标参数更直观。例如，将第一个键设置为预测，第二个键设置为标签，以从 `engine.state.output` 获取指标的期望数据

from monai.handlers import MeanDice, from_engine

metric = MeanDice(
    include_background=False,
    output_transform=from_engine(["pred", "label"])
)
参数:

  • keys (Union[Collection[Hashable], Hashable]) – 指定的键，用于从字典或解批处理的字典列表中提取数据。

  • first (bool) – 如果输入数据是字典列表，是否只从第一个项中提取指定的键，用于提取没有批处理维度的标量数据，这些数据在解批处理时被复制到每个字典中，例如 `loss` 等。

返回类型:

Callable

monai.handlers.utils.stopping_fn_from_loss()[source]#

返回一个用于 ignite.handlers.EarlyStopping 的停止函数，使用损失值。

返回类型:

Callable[Engine, Any]

monai.handlers.utils.stopping_fn_from_metric(metric_name)[source]#

返回一个用于 ignite.handlers.EarlyStopping 的停止函数，使用给定的指标名称。

返回类型:

Callable[Engine, Any]

monai.handlers.utils.write_metrics_reports(save_dir, images, metrics, metric_details, summary_ops, deli=',', output_type='csv', class_labels=None)[source]#

实用函数，用于将指标写入文件，包含 3 个部分：1. 如果 `metrics` 字典不为 None，将总体指标写入文件，每行是一个指标名称和值对。2. 如果 `metric_details` 字典不为 None，将每个图像的原始指标数据写入文件，每行对应一个图像。3. 如果 `summary_ops` 不为 None，则根据对 `metric_details` 的操作计算汇总并写入文件。

参数:

  • save_dir – 保存所有指标报告的目录。

  • images – 与 metric_details 数据对应的每个输入图像的名称或路径。如果为 None，将使用索引号作为每个输入图像的文件名。

  • metrics – (指标名称, 指标值) 对的字典。

  • metric_details – (指标名称, 指标原始值) 对的字典，通常来自指标计算，例如，原始值可以是每个输入图像的每个通道的 mean_dice。

  • summary_ops –

    预期用于生成摘要报告的计算操作。可以是: None, “*” 或字符串列表，默认为 None。None - 不为每个预期的 metric_details 生成摘要报告。“*” - 为每个 metric_details 生成包含所有支持操作的摘要报告。字符串列表 - 为每个 metric_details 生成包含指定操作的摘要报告，它们应在列表 [“mean”, “median”, “max”, “min”, “<int>percentile”, “std”, “notnans”] 中。“<int>percentile” 中的数字应在 [0, 100] 范围内，例如：“15percentile”。默认为：“90percentile”。更多详细信息，请参阅：https://numpy.com.cn/doc/stable/reference/generated/numpy.nanpercentile.html。请注意：对于总体摘要，它首先计算每张图像所有类别的 nanmean，然后再计算摘要。生成的摘要报告示例

    class    mean    median    max    5percentile 95percentile  notnans
class0  6.0000   6.0000   7.0000   5.1000      6.9000       2.0000
class1  6.0000   6.0000   6.0000   6.0000      6.0000       1.0000
mean    6.2500   6.2500   7.0000   5.5750      6.9250       2.0000

  • deli – 保存文件中的分隔符，默认为 “,”，因为默认输出类型是 `csv`。与以下链接保持一致：https://docs.pythonlang.cn/3/library/csv.html#csv.Dialect.delimiter。

  • output_type – 预期输出文件类型，支持的类型：[“csv”]，默认为 “csv” 。

  • class_labels – 用于在输出报告中命名类别的类名列表，如果为 None，则使用“class0”, …, “classn”，默认为 None。

Probability Map Handlers#

class monai.handlers.probability_maps.ProbMapProducer(output_dir='./', output_postfix='', prob_key='pred', dtype=<class 'numpy.float64'>, name=None)[source]#

事件处理程序，在每次迭代完成时触发，用于计算并保存概率图。此处理程序使用来自 MetaTensor 的元数据来创建概率图。使用 `monai.data.SlidingPatchWSIDataset` 或 `monai.data.MaskedPatchWSIDataset` 作为数据集可以轻松实现这一点。

__init__(output_dir='./', output_postfix='', prob_key='pred', dtype=<class 'numpy.float64'>, name=None)[source]#
参数:

  • output_dir – 保存概率图的输出目录。

  • output_postfix – 附加到所有输出文件名的字符串。

  • prob_key – 与模型的概率输出相关联的键

  • dtype – 存储概率图的数据类型。默认为 np.float64。

  • name – 要使用的 logging.logger 的标识符，默认为 engine.logger。

attach(engine)[source]#
参数:

engine (Engine) – Ignite 引擎，可以是训练器、验证器或评估器。

返回类型:

None

save_prob_map(name)[source]#

此方法在图像推理完成后保存该图像的概率图，并从内存中删除该概率图。

参数:

name (str) – 要保存的图像的名称。

返回类型:

None

在本页
查看源代码