Auto3dseg#

class monai.auto3dseg.Algo[source]#

在此语境下，算法被宽泛地定义为由多个组件组成的数据处理流水线，例如图像预处理，随后是深度学习模型的训练和评估。

注意

当通过 algo_to_json / algo_from_json 进行序列化时，子类将通过 monai.bundle.ConfigParser 从其完全限定的类名重新实例化。这要求子类具有默认构造函数（没有必需的位置参数）；之后通过 load_state_dict 恢复状态。

get_output_path(*args, **kwargs)[source]#: 返回用于脚本存放的算法输出路径。

get_score(*args, **kwargs)[source]#: 返回基于训练和验证数据集的模型质量度量。

load_state_dict(state)[source]#

从字典恢复状态。

子类应重写此方法，以从 state_dict() 返回的字典中恢复其状态。

参数:: state (dict) – 包含要恢复状态的字典。
返回类型:: None

predict(*args, **kwargs)[source]#: 读取测试数据并输出模型预测。

set_data_stats(*args, **kwargs)[source]#: 提供数据集（及摘要），以便模型创建过程可以依赖于输入数据集。

state_dict()[source]#

返回用于序列化的状态。

子类应重写此方法，以返回需要序列化的属性字典。这遵循 PyTorch 的状态管理惯例。

返回类型:: dict
返回:: 包含要序列化状态的字典。

train(*args, **kwargs)[source]#: 读取训练/验证数据并输出模型。

class monai.auto3dseg.AlgoGen[source]#

一种数据驱动的算法生成器。它可选择性地接收以下输入：

训练数据集属性（例如来自 monai.auto3dseg.analyzer 的数据统计信息），

之前评估模型质量的算法分数，

计算预算，

并生成 Algo 实例。生成的算法将使用训练数据集进行训练。

                          scores
                +------------------------+
                |   +---------+          |
+-----------+   +-->|         |    +-----+----+
| Dataset,  |       | AlgoGen |--->|   Algo   |
| summaries |------>|         |    +----------+
+-----+-----+       +---------+          ^
      |                                  |
      +----------------------------------+

此类还维护先前生成的算法及其相应验证分数的历史记录。算法生成过程可能是随机的（使用 Randomizable.R 作为随机源）。

generate()[source]#: 生成新的算法——基于 data_stats、预算以及先前算法生成的历史记录。

get_budget(*args, **kwargs)[source]#: 获取当前的计算预算。

get_data_stats(*args, **kwargs)[source]#: 获取当前数据集摘要。

get_history(*args, **kwargs)[source]#: 获取先前生成的算法。

run_algo(*args, **kwargs)[source]#

启动算法。这对于无需分布式训练任务的轻量级算法很有用。

如果生成的算法需要大量的并行执行调度，建议使用单独实现的作业调度器/控制器来运行它们。在这种情况下，控制器还应报告分数和算法历史记录，以便未来的 AlgoGen.generate 可以利用这些信息。

set_budget(*args, **kwargs)[source]#: 提供计算预算，以便生成器输出消耗合理资源的算法。

set_data_stats(*args, **kwargs)[source]#: 提供数据集摘要/属性，以便生成器可以根据输入数据集进行条件处理。

set_score(*args, **kwargs)[source]#: 来自先前生成算法的反馈，该分数可用于新的算法生成。

class monai.auto3dseg.Analyzer(stats_name, report_format)[source]#

Analyzer 组件是一个基类。继承此类的其他类将提供一个与类名相同的可调用对象，并为输入数据生成一个预格式化的字典。格式由继承此基类的类的 init 函数预定义。函数操作也可以在可调用对象运行时之前注册。

参数:: report_format (dict) – 概述报告格式关键结构的字典。

get_report_format()[source]#

通过递归解析注册的操作来获取报告格式。

返回:: None} 对。
返回类型:: 带有 {keys 的字典

resolve_format(report)[source]#

解析预定义报告的格式。

参数:: report (dict) – 要解析的字典。值将被原地替换。
返回类型:: None

static unwrap_ops(func)[source]#

解包函数值，并在运行时实际调用函数时在字典中生成同一组键。

参数:: func – 表示统计操作的操作子类对象。func 对象应有一个 data 字典，用于存储统计操作信息。对于某些操作（例如 ImageStats），它可能还包含 data_addon 属性，这是更新过程的一部分。
返回:: 带有特定键集的字典。

update_ops(key, op)[source]#

向 Analyzer 注册一个统计操作并更新 report_format。

参数:

key (str) – 报告中的值键。
op (Operations) – 表示统计操作的操作子类对象。

返回类型:

None

update_ops_nested_label(nested_key, op)[source]#

更新嵌套标签格式的操作。report_format 中的操作值将被解析为一个仅包含键的字典。

参数:

nested_key (str) – 格式为 ‘key1#0#key2’ 的字符串。
op (Operations) – 表示统计操作的操作子类对象。

返回类型:

None

class monai.auto3dseg.FgImageStats(image_key, label_key, stats_name=image_foreground_stats)[source]#

用于为每个案例（图像和标签）提取前景标签属性的分析器。

参数:

image_key (str) – 在可调用函数输入 (data) 中查找图像数据的键。
label_key (str) – 在可调用函数输入 (data) 中查找标签数据的键。

示例

import numpy as np
from monai.auto3dseg import FgImageStats

input = {}
input['image'] = np.random.rand(1,30,30,30)
input['label'] = np.ones([30,30,30])
analyzer = FgImageStats(image_key='image', label_key='label')
print(analyzer(input)["image_foreground_stats"])

class monai.auto3dseg.FgImageStatsSumm(stats_name=image_foreground_stats, average=True)[source]#

此摘要分析器处理字典列表中特定键 stats_name 的值。通常，字典列表是同名案例分析器 (FgImageStats) 的输出。

参数:

stats_name (str) – 字典中待处理值的键。
average (UnionType[bool, None]) – 是否跨不同图像模态平均统计值。

class monai.auto3dseg.FilenameStats(key, stats_name)[source]#

此类查找加载的图像/标签的文件路径，并将该信息作为 monai 变换写入数据流水线。

参数:

key (UnionType[str, None]) – 用于获取文件名的键（例如，“image”，“label”）。
stats_name (str) – 用于在输出统计报告中存储文件名的键。

class monai.auto3dseg.ImageStats(image_key, stats_name=image_stats)[source]#

用于提取每个案例（图像）的图像统计属性的分析器。

参数:: image_key (str) – 在可调用函数输入 (data) 中查找图像数据的键。

示例

import numpy as np
from monai.auto3dseg import ImageStats
from monai.data import MetaTensor

input = {}
input['image'] = np.random.rand(1,30,30,30)
input['image'] = MetaTensor(np.random.rand(1,30,30,30))  # MetaTensor
analyzer = ImageStats(image_key="image")
print(analyzer(input)["image_stats"])

注意

如果图像数据是 NumPy 数组，间距统计信息将是数组 ndims 的 [1.0] * ndims，其中 ndims 是图像维度和 3 之间的较小值。

class monai.auto3dseg.ImageStatsSumm(stats_name=image_stats, average=True)[source]#

此摘要分析器处理字典列表中特定键 stats_name 的值。通常，字典列表是同名前缀案例分析器 (ImageStats) 的输出。

参数:

stats_name (str) – 字典中待处理值的键。
average (UnionType[bool, None]) – 是否跨不同图像模态平均统计值。

class monai.auto3dseg.LabelStats(image_key, label_key, stats_name=label_stats, do_ccp=True)[source]#

用于提取每个案例（图像和标签）的标签统计属性的分析器。

参数:

image_key (str) – 在可调用函数输入 (data) 中查找图像数据的键。
label_key (str) – 在可调用函数输入 (data) 中查找标签数据的键。
do_ccp (UnionType[bool, None]) – 执行连通分量分析。默认为 True。

示例

import numpy as np
from monai.auto3dseg import LabelStats

input = {}
input['image'] = np.random.rand(1,30,30,30)
input['label'] = np.ones([30,30,30])
analyzer = LabelStats(image_key='image', label_key='label')
print(analyzer(input)["label_stats"])

class monai.auto3dseg.LabelStatsSumm(stats_name=label_stats, average=True, do_ccp=True)[source]#

此摘要分析器处理字典列表中特定键 stats_name 的值。通常，字典列表是同名案例分析器 (LabelStats) 的输出。

参数:

stats_name (str) – 字典中待处理值的键。
average (UnionType[bool, None]) – 是否跨不同图像模态平均统计值。

class monai.auto3dseg.Operations(dict=None, /, **kwargs)[source]#

操作接口的基类。

evaluate(data, **kwargs)[source]#

对于 self.data 中的键值对，如果值是可调用的，则此函数会将该可调用对象应用于输入数据。结果将写入输出字典中的相同键下。

参数:

data (Any) – 输入数据。

返回类型:

dict

返回:

如果值为: 可调用的，则返回一个与 self.data 具有相同键的字典。

class monai.auto3dseg.SampleOperations[source]#

对样本（图像/ndarray/张量）应用统计操作。

注意

百分位数操作使用一个嵌入不同 kwargs (q) 的偏函数。为了美观地打印结果，添加了 data_addon 以将百分位数生成的数字映射到不同的键（例如“percentile_00_5”）。后缀注释表示百分位数计算的百分比。例如，_00_5 表示 0.5%，_99_5 表示 99.5%。

示例

# use the existing operations
import numpy as np
op = SampleOperations()
data_np = np.random.rand(10, 10).astype(np.float64)
print(op.evaluate(data_np))

# add a new operation
op.update({"sum": np.sum})
print(op.evaluate(data_np))

evaluate(data, **kwargs)[source]#

将可调用对象应用于数据，并将数值转换为列表或 Python 数值类型 (int/float)。

参数:: data (Any) – 输入数据。
返回类型:: dict

class monai.auto3dseg.SegSummarizer(image_key, label_key, average=True, do_ccp=True, hist_bins=None, hist_range=None, histogram_only=False)[source]#

SegSummarizer 为 Auto3Dseg 流水线中的数据分析序列化操作。它加载两种类型的分析器函数并以不同方式执行。第一种类型的分析器是 CaseAnalyzer，类似于传统的 monai 变换。它可以与其他变换组合使用，以处理具有图像/标签键的数据字典。第二种类型的分析器是 SummaryAnalyzer，仅适用于字典列表。每个字典都是单个数据集上案例分析器的输出。

参数:

image_key (str) – 用户为图像指定的字符串。DataAnalyzer 将在 datalist 中查找它以定位数据集的图像文件。
label_key (UnionType[str, None]) – 用户为标签指定的字符串。DataAnalyzer 将在 datalist 中查找它以定位数据集的标签文件。如果 label_key 为 None，DataAnalyzer 将跳过查找标签及所有与标签相关的操作。
do_ccp (bool) – 应用连通分量算法来处理标签/图像。
hist_bins (Union[list[int], int, None]) – 正整数列表（每个通道一个），用于设置计算直方图时使用的 bin 数量。默认为 [100]。
hist_range (Optional[list, None]) – 两个浮点数列表的列表（每个通道一个），用于设置计算直方图的强度范围。默认为 [-500, 500]。
histogram_only (bool) – 是否仅计算直方图。默认为 False。

示例

# imports

summarizer = SegSummarizer("image", "label")
transform_list = [
    LoadImaged(keys=keys),
    EnsureChannelFirstd(keys=keys),  # this creates label to be (1,H,W,D)
    ToDeviced(keys=keys, device=device, non_blocking=True),
    Orientationd(keys=keys, axcodes="RAS"),
    EnsureTyped(keys=keys, data_type="tensor"),
    Lambdad(keys="label", func=lambda x: torch.argmax(x, dim=0, keepdim=True) if x.shape[0] > 1 else x),
    SqueezeDimd(keys=["label"], dim=0),
    summarizer,
]
...
# skip some steps to set up data loader
dataset = data.DataLoader(ds, batch_size=1, shuffle=False, num_workers=n_workers, collate_fn=no_collation)
transform = Compose(transform_list)
stats = []
for batch_data in dataset:
    d = transform(batch_data[0])
    stats.append(d)
report = summarizer.summarize(stats)

add_analyzer(case_analyzer, summary_analyzer)[source]#

向引擎添加新的分析器，以便可调用和总结函数利用这些新分析器进行统计计算。

参数:

case_analyzer (Analyzer) – 处理每个数据的分析器。
summary_analyzer (UnionType[Analyzer, None]) – 处理统计字典列表的分析器（来自 case_analyzers 的输出）。

示例

from monai.auto3dseg import Analyzer
from monai.auto3dseg.utils import concat_val_to_np
from monai.auto3dseg.analyzer_engine import SegSummarizer

class UserAnalyzer(Analyzer):
    def __init__(self, image_key="image", stats_name="user_stats"):
        self.image_key = image_key
        report_format = {"ndims": None}
        super().__init__(stats_name, report_format)

    def __call__(self, data):
        d = dict(data)
        report = deepcopy(self.get_report_format())
        report["ndims"] = d[self.image_key].ndim
        d[self.stats_name] = report
        return d

class UserSummaryAnalyzer(Analyzer):
    def __init__(stats_name="user_stats"):
        report_format = {"ndims": None}
        super().__init__(stats_name, report_format)
        self.update_ops("ndims", SampleOperations())

    def __call__(self, data):
        report = deepcopy(self.get_report_format())
        v_np = concat_val_to_np(data, [self.stats_name, "ndims"])
        report["ndims"] = self.ops["ndims"].evaluate(v_np)
        return report

summarizer = SegSummarizer()
summarizer.add_analyzer(UserAnalyzer, UserSummaryAnalyzer)

返回类型:: None

summarize(data)[source]#

总结输入数据列表，并生成准备导出为 json/yaml 的报告。

参数:: data (list[dict]) – 数据字典列表。
返回类型:: dict[str, dict]
返回:: 总结数据样本统计信息的字典。

示例

stats_summary

image_foreground_stats: intensity: {…}
image_stats: channels: {…} cropped_shape: {…} …
label_stats: image_intensity: {…} label: - image_intensity: {…} - image_intensity: {…} - image_intensity: {…} - image_intensity: {…}

class monai.auto3dseg.SummaryOperations[source]#

应用统计操作来总结字典。键值如下：{“max”, “min” ,”mean”, …. }。值可能以列表格式包含多个值。此操作将对该列表应用操作。通常，该字典由多个 SampleOperation 和 concat_multikeys_to_dict 函数生成。

示例

import numpy as np
data = {
    "min": np.random.rand(4),
    "max": np.random.rand(4),
    "mean": np.random.rand(4),
    "sum": np.random.rand(4),
}
op = SummaryOperations()
print(op.evaluate(data)) # "sum" is not registered yet, so it won't contain "sum"

op.update({"sum", np.sum})
print(op.evaluate(data)) # output has "sum"

evaluate(data, **kwargs)[source]#

将可调用对象应用于数据，并将数值转换为列表或 Python 数值类型 (int/float)。

参数:: data (Any) – 输入数据。
返回类型:: dict

monai.auto3dseg.algo_from_json(filename, template_path=None, **kwargs)[source]#

从 JSON 文件导入 Algo 对象（无 pickle 序列化）。

参数:

filename (str) – 保存的文件名 (algo_object.json 或旧版 algo_object.pkl)。
template_path (Union[str, PathLike, None]) – 包含实例化 Algo 所需文件的文件夹。除了 template_path，此函数还将尝试使用文件中保存的 template_path 以及包含该文件的文件夹的父文件夹中名为 algorithm_templates 的目录。
kwargs (Any) – 额外的关键字参数（保留供将来使用）。

返回:

文件中保存的 Algo 对象。algo_meta_data：文件中保存的额外关键字，例如 acc/best_metrics。

返回类型:

algo

引发异常:

ValueError – 如果文件格式无效或无法实例化 Algo 类。
ModuleNotFoundError – 如果无法实例化 Algo 类。

monai.auto3dseg.algo_from_pickle(pkl_filename, template_path=None, **kwargs)[source]#

从 pickle 文件导入 Algo 对象。不安全；建议优先使用 algo_from_json。

除非设置了 MONAI_ALLOW_PICKLE=1，否则该功能将被禁用。有关模板路径解析的详细信息，请参见 _load_legacy_pickle。

返回类型:: Any

monai.auto3dseg.algo_to_json(algo, template_path=None, **algo_meta_data)[source]#

将 Algo 对象导出为 JSON 文件（无 pickle 序列化）。

参数:

algo (Algo) – 类 Algo 对象（通常是 BundleAlgo 或其子类）。
template_path (Union[str, PathLike, None]) – 加载自定义 Algo 类时 sys.path 设置所需的路径。
algo_meta_data (Any) – 要保存的额外元数据（例如 best_metric, score）。

返回类型:

str

返回:

保存的 Algo 对象的文件名 (algo_object.json)。

monai.auto3dseg.algo_to_pickle(algo, template_path=None, **algo_meta_data)[source]#

将 Algo 对象导出为 pickle 文件。不安全；建议优先使用 algo_to_json。

Pickle 加载时可执行任意代码。除非设置了环境变量 MONAI_ALLOW_PICKLE=1，否则此功能被禁用，即使在启用时也会发出 UserWarning。请使用 algo_to_json 进行安全的、无 pickle 的序列化。

参数:

algo (Algo) – 类 Algo 对象。
template_path (Union[str, PathLike, None]) – 加载时实例化类所需的需要添加到 sys.path 的字符串路径。
algo_meta_data (Any) – 要保存的额外关键字（例如 acc/best_metrics）。

返回类型:

str

返回:

Pickle 化的 Algo 对象的文件名。

monai.auto3dseg.concat_multikeys_to_dict(data_list, fixed_keys, keys, zero_insert=True, **kwargs)[source]#

获取字典列表中在所有键上共享相同结构的嵌套值。它返回一个字典，其中的键对应找到的 nd.ndarray 值。

参数:

data_list (list[dict]) – 字典列表 {key1: {key2: np.ndarray}}。
fixed_keys (list[UnionType[str, int]]) – 记录字典元素中值路径的键列表。
keys (list[str]) – 将被迭代以生成字典输出的字符串键列表。
zero_insert (bool) – 在列表中插入一个零，以便在获取键之前可以找到元素 0 中的值。
flatten – 如果为 True，数字在拼接前会被扁平化。

返回类型:

dict[str, ndarray]

返回:

带有键 - 拼接数组对的 nd.array 的字典。

monai.auto3dseg.concat_val_to_np(data_list, fixed_keys, ragged=False, allow_missing=False, **kwargs)[source]#

获取共享相同结构的字典列表中的嵌套值。

参数:

data_list (list[dict]) – 字典列表 {key1: {key2: np.ndarray}}。
fixed_keys (list[UnionType[str, int]]) – 记录字典元素中值路径的键列表。
ragged (UnionType[bool, None]) – 如果为 True，数字可以是列表的列表或不规则格式，因此需要更改拼接模式。
allow_missing (UnionType[bool, None]) – 如果为 True，当找不到值时将返回 None。

返回类型:

ndarray

返回:

拼接数组的 nd.array。

monai.auto3dseg.datafold_read(datalist, basedir, fold=0, key='training')[source]#

读取数据字典列表 datalist。

参数:

datalist (UnionType[str, dict]) – 列出数据的 JSON 文件名，或一个字典。
basedir (str) – 图像文件所在的目录。
fold (int) – 使用哪个折叠 (0..1，如果在训练集中)。
key (str) – 通常是 ‘training’，但可以尝试 ‘validation’ 或 ‘testing’ 来获取没有标签的列表数据（用于挑战赛）。

返回类型:

tuple[list, list]

返回:

包含两个数组（训练，验证）的元组。

monai.auto3dseg.get_foreground_image(image)[source]#

通过移除图像边缘上的全零矩形来获取前景图像。开发者注意：如果前景定义不同，请更新 select_fn。

参数:: image (MetaTensor) – 要分割的 ndarray 图像。
返回类型:: ndarray
返回:: 通过移除全零边缘获得的前景图像的 ndarray。

注意

输出大小小于输入大小。

monai.auto3dseg.get_foreground_label(image, label)[source]#

获取前景图像像素值并屏蔽掉非标记区域。

参数: image：要分割的 ndarray 图像。label：带有类 ID 注释的图像输入 ndarray。

返回类型:: MetaTensor
返回:: 标签 > 0 的前景图像的一维数组。

monai.auto3dseg.get_label_ccp(mask_index, use_gpu=True)[source]#

查找所有连通分量及其边界形状。后端可以是 cuPy/cuCIM 或 Numpy，具体取决于硬件。

参数:

mask_index (MetaTensor) – 二进制掩码。
use_gpu (bool) – 是否使用 GPU/CUDA 的开关。如果 GPU 不可用，无论此设置如何，都将使用 CPU。

返回类型:

tuple[list[Any], int]

monai.auto3dseg.verify_report_format(report, report_format)[source]#

比较报告和仅包含键的 report_format。

参数:

report (dict) – 带有实际值的字典。
report_format (dict) – 仅包含键和列表嵌套值的字典。

返回类型:

bool