应用#

数据集#

class monai.apps.MedNISTDataset(root_dir, section, transform=(), download=False, seed=0, val_frac=0.1, test_frac=0.1, cache_num=9223372036854775807, cache_rate=1.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, runtime_cache=False)[source]#

用于自动下载 MedNIST 数据并生成训练、验证或测试项目的 Dataset。它基于 CacheDataset 以加速训练过程。

参数:

root_dir – 下载和加载 MedNIST 数据集的目录。
section – 预期的数据部分，可以是：training (训练)、validation (验证) 或 test (测试)。
transform – 对输入数据执行操作的变换。
download – 是否从资源链接下载和提取 MedNIST，默认为 False。如果预期文件已存在，即使设置为 True 也会跳过下载。用户可以手动将 MedNIST.tar.gz 文件或 MedNIST 文件夹复制到 root 目录。
seed – 用于随机划分训练集、验证集和测试集的随机种子，默认为 0。
val_frac – 整个数据集中验证集的百分比，默认为 0.1。
test_frac – 整个数据集中测试集的百分比，默认为 0.1。
cache_num – 要缓存的项目数量。默认为 sys.maxsize。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
cache_rate – 总缓存数据的百分比，默认为 1.0（缓存所有）。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
num_workers – 初始化计算缓存时的工作线程数。如果 num_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，则使用 1。
progress – 下载数据集和计算变换缓存内容时是否显示进度条。
copy_cache – 在应用随机变换之前是否 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容（例如，从缓存图像中随机裁剪并深度复制裁剪区域），或者如果在 multi-processing (多进程) 环境中每个缓存项只使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy 数组或 PyTorch 张量转换为连续的。这可能有助于提高后续逻辑的性能。
runtime_cache – 是否在运行时计算缓存，默认为 False 以在初始化时准备缓存内容。参见：monai.data.CacheDataset。

引发:

ValueError – 当 root_dir 不是一个目录时。
RuntimeError – 当 dataset_dir 不存在且未选择下载 (download=False) 时。

get_num_classes()[source]#

获取类别数量。

返回类型:: int

randomize(data)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: None

class monai.apps.DecathlonDataset(root_dir, task, section, transform=(), download=False, seed=0, val_frac=0.2, cache_num=9223372036854775807, cache_rate=1.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, runtime_cache=False)[source]#

用于自动下载 Medical Segmentation Decathlon 挑战赛 (http://medicaldecathlon.com/) 数据并生成训练、验证或测试项目的 Dataset。它还将从数据集的 JSON 配置文件加载这些属性。用户可以调用 get_properties() 来获取指定的属性或所有已加载的属性。它基于 monai.data.CacheDataset 以加速训练过程。

参数:

root_dir – 用户缓存和加载 MSD 数据集的本地目录。
task – 要下载和执行的任务：列表中的一个（“Task01_BrainTumour”, “Task02_Heart”, “Task03_Liver”, “Task04_Hippocampus”, “Task05_Prostate”, “Task06_Lung”, “Task07_Pancreas”, “Task08_HepaticVessel”, “Task09_Spleen”, “Task10_Colon”）。
section – 预期的数据部分，可以是：training (训练)、validation (验证) 或 test (测试)。
transform – 对输入数据执行操作的变换。进一步使用时，请使用 EnsureChannelFirstd 将形状转换为 [C, H, W, D]。
download – 是否从资源链接下载和提取 Decathlon 数据，默认为 False。如果预期文件已存在，即使设置为 True 也会跳过下载。用户可以手动将 tar 文件或数据集文件夹复制到 root 目录。
val_frac – 整个数据集中验证集的百分比，默认为 0.2。
seed – 用于在划分为训练集和验证集之前随机打乱数据列表的随机种子，默认为 0。注意为 training (训练) 和 validation (验证) 部分设置相同的种子。
cache_num – 要缓存的项目数量。默认为 sys.maxsize。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
cache_rate – 总缓存数据的百分比，默认为 1.0（缓存所有）。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
num_workers – 初始化计算缓存时的工作线程数。如果 num_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，则使用 1。
progress – 下载数据集和计算变换缓存内容时是否显示进度条。
copy_cache – 在应用随机变换之前是否 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容（例如，从缓存图像中随机裁剪并深度复制裁剪区域），或者如果在 multi-processing (多进程) 环境中每个缓存项只使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy 数组或 PyTorch 张量转换为连续的。这可能有助于提高后续逻辑的性能。
runtime_cache – 是否在运行时计算缓存，默认为 False 以在初始化时准备缓存内容。参见：monai.data.CacheDataset。

引发:

ValueError – 当 root_dir 不是一个目录时。
ValueError – 当 task 不是 [“Task01_BrainTumour”, “Task02_Heart”, “Task03_Liver”, “Task04_Hippocampus”, “Task05_Prostate”, “Task06_Lung”, “Task07_Pancreas”, “Task08_HepaticVessel”, “Task09_Spleen”, “Task10_Colon”] 中的一个时。
RuntimeError – 当 dataset_dir 不存在且未选择下载 (download=False) 时。

示例

transform = Compose(
    [
        LoadImaged(keys=["image", "label"]),
        EnsureChannelFirstd(keys=["image", "label"]),
        ScaleIntensityd(keys="image"),
        ToTensord(keys=["image", "label"]),
    ]
)

val_data = DecathlonDataset(
    root_dir="./", task="Task09_Spleen", transform=transform, section="validation", seed=12345, download=True
)

print(val_data[0]["image"], val_data[0]["label"])

get_indices()[source]#

获取此数据集中使用的数据列表索引。

返回类型:: ndarray

get_properties(keys=None)[source]#: 获取数据集的已加载属性，使用指定的键。如果未指定键，则返回所有已加载的属性。

randomize(data)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: None

class monai.apps.TciaDataset(root_dir, collection, section, transform=(), download=False, download_len=-1, seg_type='SEG', modality_tag=(8, 96), ref_series_uid_tag=(32, 14), ref_sop_uid_tag=(8, 4437), specific_tags=((8, 4373), (8, 4416), (12294, 16), (32, 13), (16, 16), (16, 32), (32, 17), (32, 18)), fname_regex='^(?!.*LICENSE).*', seed=0, val_frac=0.2, cache_num=9223372036854775807, cache_rate=0.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, runtime_cache=False)[source]#

用于自动从公共的癌症影像档案馆 (TCIA) 数据集下载数据并生成训练、验证或测试项目的 Dataset。

Highdicom 库用于加载模态为“SEG”的 dicom 数据，但只支持部分集合，例如：“C4KC-KiTS”、“NSCLC-Radiomics”、“NSCLC-Radiomics-Interobserver1”、“QIN-PROSTATE-Repeatability” 和 “PROSTATEx”。因此，如果在 LoadImaged 变换的 keys 中包含“seg”并加载其他一些集合时，可能会引发错误。对于受支持的集合，原始的“SEG”信息对于每个 dicom 文件可能并不总是保持一致。因此，为避免创建不同格式的标签，在调用 LoadImaged 变换时，请使用 PydicomReader 的 label_dict 参数。上述集合的预备标签字典也保存在：monai.apps.tcia.TCIA_LABEL_DICT 中。您也可以参考下面的第二个示例。

此类基于 monai.data.CacheDataset 以加速训练过程。

参数:

root_dir – 用户缓存和加载 TCIA 数据集的本地目录。
collection – TCIA 集合的名称。一个 TCIA 数据集定义为一个集合。请检查以下列表以浏览集合列表（仅公共集合可下载）：https://www.cancerimagingarchive.net/collections/
section – 预期的数据部分，可以是：training (训练)、validation (验证) 或 test (测试)。
transform – 对输入数据执行操作的变换。进一步使用时，请使用 EnsureChannelFirstd 将形状转换为 [C, H, W, D]。如果未指定，将使用 LoadImaged(reader=”PydicomReader”, keys=[“image”]) 作为默认变换。此外，如果需要加载分割，我们建议为 PydicomReader 设置参数 labels。每个 dicom 序列的原始标签可能不同，使用此参数可以统一标签的格式。
download – 是否下载和提取数据集，默认为 False。如果预期文件已存在，即使设置为 True 也会跳过下载。用户可以手动将 tar 文件或数据集文件夹复制到 root 目录。
download_len – 将下载的序列数量，该值应大于 0 或等于 -1，其中 -1 表示将下载所有序列。默认为 -1。
seg_type – 用于进行第一步下载的分割模态类型。默认为“SEG” 。
modality_tag – 模态的标签。默认为 (0x0008, 0x0060)。
ref_series_uid_tag – 参考的序列实例 UID 的标签。默认为 (0x0020, 0x000e)。
ref_sop_uid_tag – 参考的 SOP 实例 UID 的标签。默认为 (0x0008, 0x1155)。
specific_tags – 将为“SEG”序列加载的标签。此参数将用于 monai.data.PydicomReader。默认为 [(0x0008, 0x1115), (0x0008,0x1140), (0x3006, 0x0010), (0x0020,0x000D), (0x0010,0x0010), (0x0010,0x0020), (0x0020,0x0011), (0x0020,0x0012)]。
fname_regex – 当输入是文件夹时用于匹配文件名的正则表达式。如果提供，将只包含匹配的文件。例如，要包含文件名“image_0001.dcm”，正则表达式可以是 “.*image_(d+).dcm”。默认为 “^(?!.*LICENSE).*”，忽略任何包含 “LICENSE” 的文件名。
val_frac – 整个数据集中验证集的百分比，默认为 0.2。
seed – 用于在划分为训练集和验证集之前随机打乱数据列表的随机种子，默认为 0。注意为 training (训练) 和 validation (验证) 部分设置相同的种子。
cache_num – 要缓存的项目数量。默认为 sys.maxsize。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
cache_rate – 总缓存数据的百分比，默认为 0.0（不缓存）。将取 (cache_num, data_length x cache_rate, data_length) 中的最小值。
num_workers – 初始化计算缓存时的工作线程数。如果 num_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，则使用 1。
progress – 下载数据集和计算变换缓存内容时是否显示进度条。
copy_cache – 在应用随机变换之前是否 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容（例如，从缓存图像中随机裁剪并深度复制裁剪区域），或者如果在 multi-processing (多进程) 环境中每个缓存项只使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy 数组或 PyTorch 张量转换为连续的。这可能有助于提高后续逻辑的性能。
runtime_cache – 是否在运行时计算缓存，默认为 False 以在初始化时准备缓存内容。参见：monai.data.CacheDataset。

示例

# collection is "Pancreatic-CT-CBCT-SEG", seg_type is "RTSTRUCT"
data = TciaDataset(
    root_dir="./", collection="Pancreatic-CT-CBCT-SEG", seg_type="RTSTRUCT", download=True
)

# collection is "C4KC-KiTS", seg_type is "SEG", and load both images and segmentations
from monai.apps.tcia import TCIA_LABEL_DICT
transform = Compose(
    [
        LoadImaged(reader="PydicomReader", keys=["image", "seg"], label_dict=TCIA_LABEL_DICT["C4KC-KiTS"]),
        EnsureChannelFirstd(keys=["image", "seg"]),
        ResampleToMatchd(keys="image", key_dst="seg"),
    ]
)
data = TciaDataset(
    root_dir="./", collection="C4KC-KiTS", section="validation", seed=12345, download=True
)

print(data[0]["seg"].shape)

get_indices()[source]#

获取此数据集中使用的数据列表索引。

返回类型:: ndarray

获取此数据集中使用的数据列表索引。

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: None

randomize(data)[source]#

基于通用数据集的交叉验证数据集，该数据集必须具有 _split_datalist API。

参数:

dataset_cls (object) – 用于创建交叉验证分区的 dataset 类。它必须具有 _split_datalist API。
nfolds (int) – 用于交叉验证的数据折叠数。
seed (int) – 用于在划分为 N 个折叠之前随机打乱数据列表的随机种子，默认为 0。
dataset_params (Any) – dataset_cls 基类的其他附加参数。

5 折交叉验证训练示例

cvdataset = CrossValidation(
    dataset_cls=DecathlonDataset,
    nfolds=5,
    seed=12345,
    root_dir="./",
    task="Task09_Spleen",
    section="training",
    transform=train_transform,
    download=True,
)
dataset_fold0_train = cvdataset.get_dataset(folds=[1, 2, 3, 4])
dataset_fold0_val = cvdataset.get_dataset(folds=0, transform=val_transform, download=False)
# execute training for fold 0 ...

dataset_fold1_train = cvdataset.get_dataset(folds=[0, 2, 3, 4])
dataset_fold1_val = cvdataset.get_dataset(folds=1, transform=val_transform, download=False)
# execute training for fold 1 ...

...

dataset_fold4_train = ...
# execute training for fold 4 ...

get_dataset(folds, **dataset_params)[source]#

根据交叉验证组中指定的折叠索引生成数据集。

参数:

folds – 用于训练或验证的折叠索引，如果是一个值列表，则连接数据。
dataset_params – dataset_cls 基类的其他附加参数，将覆盖 self.dataset_params 中的同名参数。

Clara MMARs#

monai.apps.download_mmar(item, mmar_dir=None, progress=True, api=True, version=-1)[source]#

从 Nvidia Clara Train 下载和提取医疗模型档案 (MMAR)。

另请参见

https://docs.nvda.net.cn/clara/
Nvidia NGC Registry CLI
https://docs.nvda.net.cn/clara/clara-train-sdk/pt/mmar.html

参数:

item – MODEL_DESC 中对应的模型项。或者当 api 为 True 时，用于查询 NGC 模型名称字段的子字符串。
mmar_dir – 存储 MMAR 的目标目录，默认为 torch.hub get_dir() 下的 mmars 子文件夹。
progress – 是否显示进度条。
api – 是否通过 API 查询 NGC 并下载。
version – 要下载的 MMAR 版本。-1 表示 NGC 中的最新版本。

示例:

>>> from monai.apps import download_mmar
>>> download_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".")
>>> download_mmar("prostate_mri_segmentation", mmar_dir=".", api=True)

返回:: 下载模型的本地目录。如果 api 为 True，则返回下载模型本地目录的列表。

monai.apps.load_from_mmar(item, mmar_dir=None, progress=True, version=-1, map_location=None, pretrained=True, weights_only=False, model_key='model', api=True, model_file=None)[source]#

从 Nvidia Clara Train 下载和提取医疗模型档案 (MMAR) 模型权重。

参数:

item – MODEL_DESC 中对应的模型项。
mmar_dir – : 存储 MMAR 的目标目录，默认为 torch.hub get_dir() 下的 mmars 子文件夹。
progress – 下载内容时是否显示进度条。
version – MMAR 的版本号。将其设置为 -1 以使用 item[Keys.VERSION]。
map_location – torch.load 或 torch.jit.load 的 pytorch API 参数。
pretrained – 初始化网络模块后是否加载预训练权重。
weights_only – 是否仅加载权重而不是初始化网络模块并分配权重。
model_key – 在模型文件或配置文件中搜索模型字典的键。当前此函数假设模型字典具有 {“[name|path]”: “test.module”, “args”: {‘kw’: ‘test’}}。
api – 是否查询 NGC API 获取模型信息。
model_file – MMAR 内模型文件的相对路径。

示例:

>>> from monai.apps import load_from_mmar
>>> unet_model = load_from_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".", map_location="cpu")
>>> print(unet_model)

另请参见

https://docs.nvda.net.cn/clara/

monai.apps.MODEL_DESC#

内置不可变序列。

如果未给出参数，构造函数返回一个空元组。如果指定了可迭代对象，则从可迭代对象的项目初始化元组。

如果参数是元组，则返回值是同一个对象。

实用工具#

monai.apps.check_hash(filepath, val=None, hash_type='md5')[source]#

验证指定文件的哈希签名。

参数:

filepath – 要验证哈希值的源文件路径。
val – 文件的预期哈希值。
hash_type – 要使用的哈希算法类型，默认为 “md5”。支持的哈希类型有 “md5”、“sha1”、“sha256”、“sha512”。另请参见：monai.apps.utils.SUPPORTED_HASH_TYPES。

monai.apps.download_url(url, filepath='', hash_val=None, hash_type='md5', progress=True, **gdown_kwargs)[source]#

从指定的 URL 链接下载文件，支持进度条和哈希检查。

参数:

url – 下载文件的源 URL 链接。
filepath – 保存下载文件的目标文件路径（包括文件名）。如果未定义，将使用 os.path.basename(url)。
hash_val – 用于验证下载文件的预期哈希值。如果为 None，则跳过哈希验证。
hash_type – ‘md5’ 或 ‘sha1’，默认为 ‘md5’。
progress – 是否显示进度条。
gdown_kwargs – 除 url、output 和 quiet 之外的 gdown 其他参数。这些参数仅在从 google drive 下载时使用。有关参数详情：wkentaro/gdown

引发:

RuntimeError – 当 filepath 现有文件的哈希验证失败时。
RuntimeError – 当网络问题或权限拒绝阻止文件从 url 下载到 filepath 时。
URLError – 参见 urllib.request.urlretrieve。
HTTPError – 参见 urllib.request.urlretrieve。
ContentTooShortError – 参见 urllib.request.urlretrieve。
IOError – 参见 urllib.request.urlretrieve。
RuntimeError – 当从 url 下载的文件哈希验证失败时。

monai.apps.extractall(filepath, output_dir='.', hash_val=None, hash_type='md5', file_type='', has_base=True)[source]#

将文件解压到输出目录。预期的文件类型包括：zip、tar.gz 和 tar。

参数:

filepath – 压缩文件的文件路径。
output_dir – 保存解压文件的目标目录。
hash_val – 用于验证压缩文件的预期哈希值。如果为 None，则跳过哈希验证。
hash_type – ‘md5’ 或 ‘sha1’，默认为 ‘md5’。
file_type – 用于解压的文件类型字符串。留空以从文件路径的基本名称推断类型。
has_base – 解压的文件是否包含一个基础文件夹。此标志用于检查现有文件夹是否由 extractall 生成，如果是，则跳过解压。例如，如果 A.zip 解压后文件结构为 A/*.png，则此标志应为 True；如果 B.zip 解压后文件结构为 *.png，则此标志应为 False。

引发:

RuntimeError – 当 filepath 压缩文件的哈希验证失败时。
NotImplementedError – 当 filepath 文件扩展名不是 [“zip”, “tar.gz”, “tar”] 中的一个时。

monai.apps.download_and_extract(url, filepath='', output_dir='.', hash_val=None, hash_type='md5', file_type='', has_base=True, progress=True)[source]#

从 URL 下载文件并将其解压到输出目录。

参数:

url – 下载文件的源 URL 链接。
filepath – 下载的压缩文件的文件路径。使用此选项保留直接下载的压缩文件，以避免进一步重复下载。
output_dir – 保存解压文件的目标目录。默认为当前目录。
hash_val – 用于验证下载文件的预期哈希值。如果为 None，则跳过哈希验证。
hash_type – ‘md5’ 或 ‘sha1’，默认为 ‘md5’。
file_type – 用于解压的文件类型字符串。留空以从 URL 的基本文件名推断类型。
has_base – 解压的文件是否包含一个基础文件夹。此标志用于检查现有文件夹是否由 extractall 生成，如果是，则跳过解压。例如，如果 A.zip 解压后文件结构为 A/*.png，则此标志应为 True；如果 B.zip 解压后文件结构为 *.png，则此标志应为 False。
progress – 是否显示进度条。

Deepgrow#

monai.apps.deepgrow.dataset.create_dataset(datalist, output_dir, dimension, pixdim, image_key='image', label_key='label', base_dir=None, limit=0, relative_path=False, transforms=None)[source]#

用于预处理现有 Deepgrow 训练的数据集列表并创建新列表的实用工具。输入数据列表通常是需要为 Deepgrow 训练管道进行预处理的图像和标签（3D 体积）列表。

参数:

datalist –
数据字典列表。每个条目至少应包含 ‘image_key’: <image filename>。例如，典型的输入数据可以是一个字典列表
```
[{'image': <image filename>, 'label': <label filename>}]
```
output_dir – 存储 Deepgrow 训练数据的目标目录
pixdim – 输出体素间距。
dimension – 用于 Deepgrow 训练的维度。可以是 2 或 3。
image_key – 输入数据列表中的图像键。默认为 ‘image’。
label_key – 输入数据列表中的标签键。默认为 ‘label’。
base_dir – 如果数据列表中的键使用相对路径，则为基础目录。默认为 None。
limit – 预处理输入的数量限制。默认为 0（无限制）。
relative_path – 输出键值应基于相对路径。默认为 False。
transforms – 对输入数据执行操作的显式变换。

引发:

ValueError – 当 dimension 不是 [2, 3] 中的一个时。
ValueError – 当 datalist 为空时。

返回:

一个新的数据列表，包含预处理后的图像/标签路径。

示例

datalist = create_dataset(
    datalist=[{'image': 'img1.nii', 'label': 'label1.nii'}],
    base_dir=None,
    output_dir=output_2d,
    dimension=2,
    image_key='image',
    label_key='label',
    pixdim=(1.0, 1.0),
    limit=0,
    relative_path=True
)

print(datalist[0]["image"], datalist[0]["label"])

class monai.apps.deepgrow.interaction.Interaction(transforms, max_interactions, train, key_probability='probability')[source]#

Ignite 的 process_function，用于为 Deepgrow 训练/评估引入交互（模拟点击）。更多详情请参考：https://pytorch.ac.cn/ignite/generated/ignite.engine.engine.Engine.html。此实现基于

Sakinis et al., Interactive segmentation of medical images through fully convolutional neural networks. (2019) https://arxiv.org/abs/1903.08205

参数:

transforms – 在每次迭代期间（训练前）执行额外的变换。通常，是由 Compose 组合的多个基于张量的变换。
max_interactions – 每次迭代的最大交互次数
train – 训练或评估
key_probability – 用于填充每次交互概率的字段名

class monai.apps.deepgrow.transforms.AddInitialSeedPointd(label='label', guidance='guidance', sids='sids', sid='sid', connected_regions=5)[source]#

为给定标签添加随机引导作为初始种子点。

注意标签的大小为 (C, D, H, W) 或 (C, H, W)

引导的大小为 (2, N, # of dims)，其中 N 是添加的引导数量。当为 C, D, H, W 时，# of dims = 4；当为 (C, H, W) 时，# of dims = 3。

参数:

label (str) – 标签源。
guidance (str) – 存储引导的键。
sids (str) – 表示给定标签的有效切片索引列表的键。
sid (str) – 表示添加初始种子点的切片的键。如果不存在，将选择随机 sid。
connected_regions (int) – 用于添加初始点的最大连通区域数量。

randomize(data)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。

class monai.apps.deepgrow.transforms.AddGuidanceSignald(image='image', guidance='guidance', sigma=2, number_intensity_ch=1)[source]#

为输入图像添加引导信号。

基于“引导”点，对其应用高斯滤波，并将其作为新通道添加到输入图像。

参数:

image (str) – 图像源的键。
guidance (str) – 存储引导的键。
sigma (int) – 高斯核的标准差。
number_intensity_ch (int) – 通道索引。

class monai.apps.deepgrow.transforms.AddRandomGuidanced(guidance='guidance', discrepancy='discrepancy', probability='probability')[source]#

根据标签和预测之间发现的差异添加随机引导。输入形状如下：引导的形状为 (2, N, # of dim)，差异的形状为 (2, C, D, H, W) 或 (2, C, H, W)，概率的形状为 (1)。

参数:

guidance (str) – 引导源的键。
discrepancy (str) – 表示标签和预测之间发现的差异的键。
probability (str) – 表示点击/交互概率的键。

randomize(data=None)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。

class monai.apps.deepgrow.transforms.AddGuidanceFromPointsd(ref_image, guidance='guidance', foreground='foreground', background='background', axis=0, depth_first=True, spatial_dims=2, slice_key='slice', meta_keys=None, meta_key_postfix='meta_dict')[source]#

根据用户点击添加引导。

我们假设输入由 LoadImaged 加载，并且原始形状为 (H, W, D)。点击总是指定 (H, W, D) 中的坐标。

如果 depth_first 为 True

输入现在的形状为 (D, H, W)，将返回指定 (D, H, W) 中坐标的引导。

否则

输入现在的形状为 (H, W, D)，将返回指定 (H, W, D) 中坐标的引导。

参数:

ref_image – 用于获取当前和原始图像详细信息的参考图像键。
guidance – 存储引导的输出键。
foreground – 表示用户前景 (+ve) 点击的键。
background – 表示用户背景 (-ve) 点击的键。
axis – 表示 3D 体积中切片的轴。（轴到深度）
depth_first – 如果深度（切片）位于第一维度。
spatial_dims – 基于 Deepgrow 使用的模型（2D 或 3D）的维度。
slice_key – 表示适用切片以添加引导的键。
meta_keys – 显式指示 ref_image 元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 {ref_image}_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_key 为 None，则使用 {ref_image}_{meta_key_postfix} 根据键数据获取/存储元数据，默认为 meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。

class monai.apps.deepgrow.transforms.SpatialCropForegroundd(keys, source_key, spatial_size, select_fn=<function is_positive>, channel_indices=None, margin=0, allow_smaller=True, meta_keys=None, meta_key_postfix='meta_dict', start_coord_key='foreground_start_coord', end_coord_key='foreground_end_coord', original_shape_key='foreground_original_shape', cropped_shape_key='foreground_cropped_shape', allow_missing_keys=False)[source]#

仅裁剪预期图像的前景对象。

与 monai.transforms.CropForegroundd 的区别

如果边界框在所有维度上都小于空间大小，则此变换将使用边界框中心和 spatial_size 裁剪对象。

此变换将在 data[{key}_{meta_key_postfix}] 中设置“start_coord_key”、“end_coord_key”、“original_shape_key”和“cropped_shape_key”。

典型用法是帮助训练和评估，尤其当整个医学图像中有效部分很小时。有效部分可以通过数据中任何具有 source_key 的字段确定，例如

选择图像字段中 > 0 的值作为前景，并对由 keys 指定的所有字段进行裁剪。
选择标签字段中等于 3 的值作为前景，并对由 keys 指定的所有字段进行裁剪。
选择 One-Hot 标签字段第三个通道中 > 0 的值作为前景，并裁剪所有 keys 字段。

用户可以定义任意函数来从整个源图像或指定通道中选择预期前景。它还可以为前景对象的边界框的每个维度添加边距 (margin)。

参数:

keys – 待变换的对应项的键。另请参见：monai.transforms.MapTransform
source_key – 用于生成前景边界框的数据源，可以是图像或标签等。
spatial_size – 图像块的最小空间大小，例如 [128, 128, 128] 以适应。
select_fn – 选择预期前景的函数，默认为选择 > 0 的值。
channel_indices – 如果定义，仅在指定的图像通道上选择前景。如果为 None，则在整个图像上选择前景。
margin – 为边界框的空间维度添加边距值，如果只提供 1 个值，则对所有维度使用该值。
allow_smaller – 使用 margin 计算边界框大小时，是否允许图像大小小于边界框大小，默认为 True。如果带有边距的大小大于图像大小，将使用指定的 mode 进行填充。
meta_keys – 显式指示对应元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 key_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_keys 为 None，则使用 {key}_{meta_key_postfix} 根据键数据获取/存储元数据，默认为 meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
start_coord_key – 记录前景空间边界框起始坐标的键。
end_coord_key – 记录前景空间边界框结束坐标的键。
original_shape_key – 记录前景原始形状的键。
cropped_shape_key – 记录前景裁剪后形状的键。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.deepgrow.transforms.SpatialCropGuidanced(keys, guidance, spatial_size, margin=20, meta_keys=None, meta_key_postfix='meta_dict', start_coord_key='foreground_start_coord', end_coord_key='foreground_end_coord', original_shape_key='foreground_original_shape', cropped_shape_key='foreground_cropped_shape', allow_missing_keys=False)[source]#

根据引导信息裁剪图像，并使其具有最小空间尺寸。

如果边界框在所有维度上都小于空间大小，则此变换将使用边界框中心和 spatial_size 裁剪对象。
此变换将在 data[{key}_{meta_key_postfix}] 中设置“start_coord_key”、“end_coord_key”、“original_shape_key”和“cropped_shape_key”。

输入数据的形状为 (C, spatial_1, [spatial_2, …])

参数:

keys – 需要进行变换的相应项的键。
guidance – 引导信息的键。用于生成前景的边界框。
spatial_size – 图像块的最小空间大小，例如 [128, 128, 128] 以适应。
margin – 为边界框的空间维度添加边距值，如果只提供 1 个值，则对所有维度使用该值。
meta_keys – 显式指示对应元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 key_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_keys 为 None，则根据键数据使用 key_{postfix} 获取元数据，默认为 meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
start_coord_key – 记录前景空间边界框起始坐标的键。
end_coord_key – 记录前景空间边界框结束坐标的键。
original_shape_key – 记录前景原始形状的键。
cropped_shape_key – 记录前景裁剪后形状的键。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.deepgrow.transforms.RestoreLabeld(keys, ref_image, slice_only=False, mode=nearest, align_corners=None, meta_keys=None, meta_key_postfix='meta_dict', start_coord_key='foreground_start_coord', end_coord_key='foreground_end_coord', original_shape_key='foreground_original_shape', cropped_shape_key='foreground_cropped_shape', allow_missing_keys=False, restore_resizing=True, restore_cropping=True, restore_spacing=True, restore_slicing=True)[source]#

根据参考图像恢复标签。

假设 ref_image 经过以下变换

Fetch2DSliced (如果为 2D)

Spacingd

SpatialCropGuidanced

Resized

并且其形状假定为 (C, D, H, W)

此变换尝试撤消这些操作，以便结果标签可以与原始体素重叠。它执行以下操作

撤消 Resized

撤消 SpatialCropGuidanced

撤消 Spacingd

撤消 Fetch2DSliced

结果标签的形状为 (D, H, W)

参数:

keys – 需要进行变换的相应项的键。
ref_image – 用于获取当前和原始图像详细信息的参考图像
slice_only – 仅应用于适用的切片，用于 2D 模型/预测
mode – {"constant", "edge", "linear_ramp", "maximum", "mean", "median", "minimum", "reflect", "symmetric", "wrap", "empty"} 列出的字符串值之一或用户提供的填充函数。默认为 "constant"。另请参阅： https://numpy.com.cn/doc/1.18/reference/generated/numpy.pad.html
align_corners – 在几何学上，我们将输入的像素视为正方形而不是点。另请参阅： https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html 它也可以是布尔值的序列，每个元素对应于 keys 中的一个键。
meta_keys – 显式指示对应元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 key_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_key 为 None，则根据键数据使用 key_{meta_key_postfix} 获取元数据，默认为 `meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
start_coord_key – 记录前景空间边界框起始坐标的键。
end_coord_key – 记录前景空间边界框结束坐标的键。
original_shape_key – 记录前景原始形状的键。
cropped_shape_key – 记录前景裁剪后形状的键。
allow_missing_keys – 如果缺少键，不引发异常。
restore_resizing – 用于启用或禁用缩放恢复，默认为 True。如果为 True，变换将把项缩放回其原始形状。
restore_cropping – 用于启用或禁用裁剪恢复，默认为 True。如果为 True，变换将把项恢复到其未裁剪的大小。
restore_spacing – 用于启用或禁用间距恢复，默认为 True。如果为 True，变换将把项重新采样回改变之前的间距。
restore_slicing – 用于启用或禁用切片恢复，默认为 True。如果为 True，变换将通过将切片恢复到其原始位置来重新组装完整体素。

class monai.apps.deepgrow.transforms.ResizeGuidanced(guidance, ref_image, meta_keys=None, meta_key_postfix='meta_dict', cropped_shape_key='foreground_cropped_shape')[source]#

根据裁剪和缩放后的图像调整引导信息的大小。

此变换假定图像已被裁剪和缩放。缩放后的形状存储在参考图像的元数据字典中。

参数:

guidance – 引导信息的键
ref_image – 用于获取当前和原始图像详细信息的参考图像的键
meta_keys – 显式指示 ref_image 元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 {ref_image}_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_key 为 None，则使用 {ref_image}_{meta_key_postfix} 根据键数据获取/存储元数据，默认为 meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
cropped_shape_key – 记录前景裁剪后形状的键。

class monai.apps.deepgrow.transforms.FindDiscrepancyRegionsd(label='label', pred='pred', discrepancy='discrepancy')[source]#

在训练期间的点击交互过程中，查找预测与实际值之间的差异。

参数:

label (str) – 标签源的键。
pred (str) – 预测源的键。
discrepancy (str) – 用于存储标签和预测之间发现的差异的键。

class monai.apps.deepgrow.transforms.FindAllValidSlicesd(label='label', sids='sids')[source]#

在标签中查找/列出所有有效切片。假定标签是形状为 CDHW 的 4D 体积，其中 C=1。

参数:

label (str) – 标签源的键。
sids (str) – 用于存储具有有效标签图的切片索引的键。

class monai.apps.deepgrow.transforms.Fetch2DSliced(keys, guidance='guidance', axis=0, meta_keys=None, meta_key_postfix='meta_dict', allow_missing_keys=False)[source]#

在 3D 体积的情况下获取一个切片。

体素仅包含空间坐标。

参数:

keys – 需要进行变换的相应项的键。
guidance – 表示引导信息的键。
axis – 表示 3D 体积中切片的轴。
meta_keys – 显式指示对应元数据字典的键。例如，对于键为 image 的数据，元数据默认位于 image_meta_dict 中。元数据是一个字典对象，包含：文件名、原始形状等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 key_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 使用 key_{meta_key_postfix} 根据键数据获取元数据，默认为 meta_dict，元数据是一个字典对象。例如，处理键 image 时，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
allow_missing_keys – 如果缺少键，不引发异常。

Pathology#

class monai.apps.pathology.inferers.SlidingWindowHoVerNetInferer(roi_size, sw_batch_size=1, overlap=0.25, mode=constant, sigma_scale=0.125, padding_mode=constant, cval=0.0, sw_device=None, device=None, progress=False, cache_roi_weight_map=False, cpu_thresh=None, extra_input_padding=None)[source]#

HoVerNet 模型推断的滑动窗口方法，每个 model.forward() 使用 sw_batch_size 个窗口。使用示例可在 monai.inferers.Inferer 基类中找到。

参数:

roi_size – 执行 SlidingWindow 评估的窗口大小。如果它包含非正分量，则将使用相应的 inputs 大小。如果 roi_size 的分量为非正值，则变换将使用 img 大小的相应分量。例如，如果 img 的第二个空间维度大小为 64，则 roi_size=(32, -1) 将被调整为 (32, 64)。
sw_batch_size – 运行窗口切片的批大小。
overlap – 扫描之间的重叠量。
mode –
{"constant", "gaussian"} 如何融合重叠窗口的输出。默认为 "constant"。
- "constant”：对所有预测给予相等权重。
- "gaussian”：对窗口边缘的预测给予较小权重。
sigma_scale – 当 mode 为 "gaussian" 时，高斯窗口的标准差系数。默认值：0.125。实际窗口 sigma 为 sigma_scale * dim_size。当 sigma_scale 为浮点数序列时，这些值表示相应空间维度上的 sigma_scale。
padding_mode – {"constant", "reflect", "replicate", "circular"} 当 roi_size 大于 inputs 时的填充模式。默认为 "constant"。另请参阅： https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html
cval – 用于“constant”填充模式的填充值。默认值：0
sw_device – 窗口数据所在的设备。默认情况下使用 inputs 的设备（以及相应的内存）。通常 sw_device 应与定义 predictor 的设备保持一致。
device – 拼接输出预测所在的设备。默认情况下使用 inputs 的设备（以及相应的内存）。例如，如果设置为 device=torch.device(‘cpu’)，则 GPU 内存消耗更少，并且与 inputs 和 roi_size 无关。输出位于 device 上。
progress – 是否打印 tqdm 进度条。
cache_roi_weight_map – 是否预计算 ROI 权重图。
cpu_thresh – 提供此值时，当输入图像体素大于此阈值（以像素/体素为单位）时，动态切换到 CPU 上拼接（以节省 GPU 内存）。否则使用 "device"。因此，输出可能最终位于 CPU 或 GPU 上。
extra_input_padding – 输入图像的填充量，它是一个偶数对的元组。更多详细信息请参阅 torch.nn.functional.pad 的 pad 参数。

Note

sw_batch_size 表示每个网络推断迭代的最大窗口数，而不是输入的批大小。

class monai.apps.pathology.losses.hovernet_loss.HoVerNetLoss(lambda_hv_mse=2.0, lambda_hv_mse_grad=1.0, lambda_np_ce=1.0, lambda_np_dice=1.0, lambda_nc_ce=1.0, lambda_nc_dice=1.0)[source]#

HoVerNet 流水线的损失函数，是三个分支损失的组合。NP（核预测）分支使用 Dice + CrossEntropy。HV（水平和垂直）质心距离分支使用 MSE + 梯度的 MSE。NC（核类别预测）分支使用 Dice + CrossEntropy。结果是这些损失的加权和。

参数:

lambda_hv_mse (float) – 应用于总损失中 HV 回归 MSE 部分的权重因子
lambda_hv_mse_grad (float) – 应用于总损失中 HV 梯度 MSE 部分的权重因子
lambda_np_ce (float) – 应用于总损失中核预测 CrossEntropyLoss 部分的权重因子
lambda_np_dice (float) – 应用于总损失中核预测 DiceLoss 部分的权重因子
lambda_nc_ce (float) – 应用于总损失中核类别预测 CrossEntropyLoss 部分的权重因子
lambda_nc_dice (float) – 应用于总损失中核类别预测 DiceLoss 部分的权重因子

forward(prediction, target)[source]#

参数:

prediction (dict[str, Tensor]) – 三个分支的预测输出字典，每个输出应具有 BNHW 的形状。
target (dict[str, Tensor]) – 三个分支的 ground truth 字典，每个 ground truth 应具有 BNHW 的形状。

返回类型:

Tensor

class monai.apps.pathology.metrics.LesionFROC(data, grow_distance=75, itc_diameter=200, eval_thresholds=(0.25, 0.5, 1, 2, 4, 8), nms_sigma=0.0, nms_prob_threshold=0.5, nms_box_size=48, image_reader_name='cuCIM')[source]#

使用 Free Response Operating Characteristic (FROC) 分数进行评估。

参数:

data (list[dict]) – 包含概率图（推断结果）和肿瘤掩膜（ground truth）的字典列表，如下所示，或者包含此类列表的 json 文件路径。{ “prob_map”: “path/to/prob_map_1.npy”, “tumor_mask”: “path/to/ground_truth_1.tiff”, “level”: 6, “pixel_spacing”: 0.243 }
grow_distance (int) – 用于增长 ground truth 肿瘤标签的欧几里得距离（以微米为单位）。默认为 75，相当于 5 个肿瘤细胞的大小。
itc_diameter (int) – 被视为孤立肿瘤细胞（isolated tumor cell）的最大区域直径（以微米为单位）。默认为 200。
eval_thresholds (tuple) – 用于计算平均敏感度的假阳性率。默认为 (0.25, 0.5, 1, 2, 4, 8)，这与 CAMELYON 16 挑战赛相同。
nms_sigma (float) – 用于非极大值抑制高斯滤波器的标准差。默认为 0.0。
nms_prob_threshold (float) – 非极大值抑制的概率阈值。默认为 0.5。
nms_box_size (int) – 用于非极大值抑制的围绕像素移除的框大小（以像素为单位）。
image_reader_name (str) – 用于加载全视野数字病理图像的库名称，可以是 CuCIM 或 OpenSlide。默认为 CuCIM。

Note

有关 nms_* 参数的更多信息，请参阅 monai.utils.prob_nms.ProbNMS`。

compute_fp_tp()[source]#: 通过比较模型输出与所有样本的 ground truth，计算肿瘤检测的假阳性和真阳性概率。

evaluate()[source]#: 根据模型概率图输出、ground truth 肿瘤掩膜及其相关元数据（例如，pixel_spacing、level）评估模型的检测性能。

prepare_ground_truth(sample)[source]#: 根据二值肿瘤掩膜准备用于评估的 ground truth。

prepare_inference_result(sample)[source]#

准备用于检测评估的概率图。

返回类型:: tuple[ndarray, ndarray, ndarray]

monai.apps.pathology.utils.compute_multi_instance_mask(mask, threshold)[source]#

此方法根据二值肿瘤掩膜计算分割掩膜。

参数:

mask (ndarray) – 二值掩膜数组
threshold (float) – 用于填充孔洞的阈值

返回类型:

Any

monai.apps.pathology.utils.compute_isolated_tumor_cells(tumor_mask, threshold)[source]#

此方法计算识别孤立肿瘤细胞（ITC）并返回其标签。

参数:

tumor_mask (ndarray) – 肿瘤掩膜。
threshold (float) – 定义孤立肿瘤细胞（ITC）的阈值（在掩膜级别）。最长直径小于此阈值的区域被视为 ITC。

返回类型:

list[int]

class monai.apps.pathology.utils.PathologyProbNMS(spatial_dims=2, sigma=0.0, prob_threshold=0.5, box_size=48)[source]#: 此类扩展了 monai.utils.ProbNMS 并为病理学添加了 resolution 选项。

class monai.apps.pathology.transforms.stain.array.ExtractHEStains(tli=240, alpha=1, beta=0.15, max_cref=(1.9705, 1.0308))[source]#

使用染色反卷积（参见 Note）从图像中提取目标染色的类。

参数:

tli – 透射光强度。默认为 240。
alpha – 伪最小值（alpha 百分位数）和伪最大值（100 - alpha 百分位数）的容差（以百分位数表示）。默认为 1。
beta – 透明像素的吸光度阈值。默认为 0.15
max_cref – 苏木精和伊红 (H&E) 的参考最大染色浓度。默认为 (1.9705, 1.0308)。

Note

更多信息请参阅： - 原始论文：Macenko 等人，2009 年 http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf - 之前的实现

MATLAB：mitkovetta/staining-normalization

Python：schaugf/HEnorm_python

class monai.apps.pathology.transforms.stain.array.NormalizeHEStains(tli=240, alpha=1, beta=0.15, target_he=((0.5626, 0.2159), (0.7201, 0.8012), (0.4062, 0.5581)), max_cref=(1.9705, 1.0308))[source]#

将切片/图像归一化到参考或目标图像染色的类（参见 Note）。

使用 ExtractHEStains 类对源图像进行染色反卷积，以获得染色矩阵并计算图像的染色浓度矩阵。然后，使用提供的目标 H&E 染色矩阵执行逆 Beer-Lambert 变换以重建切片。如果未提供目标染色，则使用默认参考染色。类似地，如果未提供最大染色浓度，则使用参考最大染色浓度矩阵。

参数:

tli – 透射光强度。默认为 240。
alpha – 伪最小值（alpha 百分位数）和伪最大值（100 - alpha 百分位数）的容差（以百分位数表示）。默认为 1。
beta – 透明像素的吸光度阈值。默认为 0.15。
target_he – 目标染色矩阵。默认为 ((0.5626, 0.2159), (0.7201, 0.8012), (0.4062, 0.5581))。
max_cref – 苏木精和伊红 (H&E) 的参考最大染色浓度。默认为 [1.9705, 1.0308]。

Note

更多信息请参阅： - 原始论文：Macenko 等人，2009 年 http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf - 之前的实现

MATLAB：mitkovetta/staining-normalization

Python：schaugf/HEnorm_python

围绕 monai.apps.pathology.transforms.array 中定义的病理学变换的字典封装器的集合。

类名以“d”结尾表示基于字典的变换。

class monai.apps.pathology.transforms.stain.dictionary.ExtractHEStainsd(keys, tli=240, alpha=1, beta=0.15, max_cref=(1.9705, 1.0308), allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.ExtractHEStains 的基于字典的封装器。使用染色反卷积从图像中提取目标染色的类。

参数:

keys – 需要进行变换的相应项的键。另请参阅： monai.transforms.compose.MapTransform
tli – 透射光强度。默认为 240。
alpha – 伪最小值（alpha 百分位数）和伪最大值（100 - alpha 百分位数）的容差（以百分位数表示）。默认为 1。
beta – 透明像素的吸光度阈值。默认为 0.15
max_cref – 苏木精和伊红 (H&E) 的参考最大染色浓度。默认为 (1.9705, 1.0308)。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.stain.dictionary.NormalizeHEStainsd(keys, tli=240, alpha=1, beta=0.15, target_he=((0.5626, 0.2159), (0.7201, 0.8012), (0.4062, 0.5581)), max_cref=(1.9705, 1.0308), allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.NormalizeHEStains 的基于字典的封装器。

将切片/图像归一化到参考或目标图像染色的类。

参数:

keys – 需要进行变换的相应项的键。另请参阅： monai.transforms.compose.MapTransform
tli – 透射光强度。默认为 240。
alpha – 伪最小值（alpha 百分位数）和伪最大值（100 - alpha 百分位数）的容差（以百分位数表示）。默认为 1。
beta – 透明像素的吸光度阈值。默认为 0.15。
target_he – 目标染色矩阵。默认为 None。
max_cref – 苏木精和伊红 (H&E) 的参考最大染色浓度。默认为 None。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.post.array.GenerateSuccinctContour(height, width)[source]#

将 SciPy 风格的轮廓（由 skimage.measure.find_contours 生成）转换为更简洁的版本，该版本仅包含需要绘制线条的像素（即，不包含沿每条线条的中间像素）。

参数:

height (int) – 边界框的高度，用于检测线段的方向。
width (int) – 边界框的宽度，用于检测线段的方向。

返回:

需要通过直线连接以描述前景最外层像素的像素，类似于 OpenCV 的 cv.CHAIN_APPROX_SIMPLE（逆时针）。: OpenCV 的 cv.CHAIN_APPROX_SIMPLE（逆时针）

class monai.apps.pathology.transforms.post.array.GenerateInstanceContour(min_num_points=3, contour_level=None)[source]#

为 2D 数组中的每个实例生成轮廓。使用 GenerateSuccinctContour 仅包含需要绘制线条的像素。

参数:

min_num_points – 假定如果创建的轮廓点数不大于指定值，则不构成轮廓。默认为 3。
contour_level – skimage.measure.find_contours 在数组中查找轮廓的可选值。如果未提供，则将级别设置为 (max(image) + min(image)) / 2。

class monai.apps.pathology.transforms.post.array.GenerateInstanceCentroid(dtype=<class 'int'>)[source]#

使用 skimage.measure.centroid 生成实例质心。

参数:: dtype – 输出质点的数据类型。

class monai.apps.pathology.transforms.post.array.GenerateInstanceType[source]#: 为每个实例生成实例类型和概率。

class monai.apps.pathology.transforms.post.array.Watershed(connectivity=1, dtype=<class 'numpy.int64'>)[source]#

使用 skimage.segmentation.watershed 从图像中获取实例分割结果。参阅： https://scikit-image.cn/docs/stable/api/skimage.segmentation.html#skimage.segmentation.watershed。

参数:

connectivity – 与图像维度相同的数组，其非零元素表示连接的邻居。遵循 scipy 约定，默认为与图像维度相同的单连接数组。
dtype – 要转换的目标数据内容类型，默认为 np.int64。

class monai.apps.pathology.transforms.post.array.GenerateWatershedMask(activation='softmax', threshold=None, min_object_size=10, dtype=<class 'numpy.uint8'>)[source]#

生成 watershed 中使用的掩膜。只有 mask == True 的点才会被标记。

参数:

activation – 应用于输入概率图的激活层。可以是“softmax”或“sigmoid”字符串，或任何可调用对象。默认为“softmax”。
threshold – 用于二值化概率图的可选浮点值。如果未提供，当激活不是“softmax”时，默认为 0.5，否则为 None。
min_object_size – 小于此大小（以像素为单位）的对象将被移除。默认为 10。
dtype – 要转换的目标数据内容类型，默认为 np.uint8。

class monai.apps.pathology.transforms.post.array.GenerateInstanceBorder(kernel_size=5, dtype=<class 'numpy.float32'>)[source]#

通过悬停图生成实例边界。图像中无法识别为前景区域的部分越多，灰度值越大。实例边界的灰度值会更大。

参数:

kernel_size (int) – Sobel 核的大小。默认为 5。
dtype (Union[dtype, type, str, None]) – 要转换的目标数据类型。默认为 np.float32。

引发:

ValueError – 当 mask 形状不是 [1, H, W] 时。
ValueError – 当 hover_map 形状不是 [2, H, W] 时。

class monai.apps.pathology.transforms.post.array.GenerateDistanceMap(smooth_fn=None, dtype=<class 'numpy.float32'>)[source]#

生成距离图。一般来说，实例图是根据到背景的距离计算的。在这里，我们使用 1 - “实例边界图”来生成距离图。核值形成“山”，因此反转它们以获得“盆地”。

参数:

smooth_fn – 距离图的平滑函数，可以是任何可调用对象。如果未提供，则使用 monai.transforms.GaussianSmooth()。
dtype – 要转换的目标数据类型。默认为 np.float32。

class monai.apps.pathology.transforms.post.array.GenerateWatershedMarkers(threshold=0.4, radius=2, min_object_size=10, postprocess_fn=None, dtype=<class 'numpy.int64'>)[source]#

生成用于 watershed 的标记。分水岭算法将像素值视为局部地形（海拔）。算法从标记点开始灌满盆地，直到属于不同标记点的盆地在分水岭线上相遇。这里是 HoVerNet 论文中的实现。更多详细信息请参阅论文：https://arxiv.org/abs/1812.06499。

参数:

threshold – 用于二值化实例边界图的浮点值。它将不确定区域变为 1，其他区域变为 0。默认为 0.4。
radius – opening 中使用的圆盘形足迹的半径。默认为 2。
min_object_size – 小于此大小（以像素为单位）的对象将被移除。默认为 10。
postprocess_fn – 对标记进行的额外后处理函数。如果未提供，将使用 monai.transforms.post.FillHoles()。
dtype – 要转换的目标数据类型。默认为 np.int64。

class monai.apps.pathology.transforms.post.array.HoVerNetNuclearTypePostProcessing(activation='softmax', threshold=None, return_type_map=True, device=None)[source]#

HoVerNet 模型的后处理变换，用于生成核类型信息。它使用核的类型信息（值和概率）更新输入的实例信息字典。如果请求（return_type_map=True），它还会生成像素级类型图。

参数:

activation – 应用于核类型分支的激活层。可以是“softmax”或“sigmoid”字符串，或任何可调用对象。默认为“softmax”。
threshold – 用于二值化概率图的可选浮点值。如果未提供，当激活不是“softmax”时，默认为 0.5，否则为 None。
return_type_map – 是否计算并返回像素级类型图。
device – 放置输出 Tensor 数据的目标设备。

class monai.apps.pathology.transforms.post.array.HoVerNetInstanceMapPostProcessing(activation='softmax', mask_threshold=None, min_object_size=10, sobel_kernel_size=5, distance_smooth_fn=None, marker_threshold=0.4, marker_radius=2, marker_postprocess_fn=None, watershed_connectivity=1, min_num_points=3, contour_level=None, device=None)[source]#

HoVerNet 模型的后处理变换，用于生成实例分割图。它生成实例分割图以及包含每个实例的质心、边界框和轮廓的字典。

参数:

activation – 应用于输入概率图的激活层。可以是“softmax”或“sigmoid”字符串，或任何可调用对象。默认为“softmax”。
mask_threshold – 用于二值化概率图生成掩膜的浮点值。
min_object_size – 小于此大小（以像素为单位）的对象将被移除。默认为 10。
sobel_kernel_size – GenerateInstanceBorder 中使用的 Sobel 核大小。默认为 5。
distance_smooth_fn – 距离图的平滑函数。如果未提供，将使用 monai.transforms.intensity.GaussianSmooth()。
marker_threshold – 用于二值化标记的实例边界图的浮点值。它将不确定区域变为 1，其他区域变为 0。默认为 0.4。
marker_radius – 用于标记的 opening 中使用的圆盘形足迹的半径。默认为 2。
marker_postprocess_fn – 分水岭标记的后处理函数。如果未提供，将使用 monai.transforms.post.FillHoles()。
watershed_connectivity – skimage.segmentation.watershed 的 connectivity 参数。
min_num_points – 被视为轮廓的最小点数。默认为 3。
contour_level – skimage.measure.find_contours 在数组中查找轮廓的可选值。如果未提供，则将级别设置为 (max(image) + min(image)) / 2。
device – 放置输出 Tensor 数据的目标设备。

class monai.apps.pathology.transforms.post.dictionary.GenerateSuccinctContourd(keys, height, width, allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.post.array.GenerateSuccinctContour 的基于字典的封装器。将 SciPy 风格的轮廓（由 skimage.measure.find_contours 生成）转换为更简洁的版本，该版本仅包含需要绘制线条的像素（即，不包含沿每条线条的中间像素）。

参数:

keys (Union[Collection[Hashable], Hashable]) – 需要进行变换的相应项的键。
height (int) – 边界框的高度，用于检测线段的方向。
width (int) – 边界框的宽度，用于检测线段的方向。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

class monai.apps.pathology.transforms.post.dictionary.GenerateInstanceContourd(keys, contour_key_postfix='contour', offset_key=None, min_num_points=3, level=None, allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.post.array.GenerateInstanceContour 的基于字典的封装器。为 2D 数组中的每个实例生成轮廓。使用 GenerateSuccinctContour 仅包含需要绘制线条的像素。

参数:

keys – 需要进行变换的相应项的键。
contour_key_postfix – 输出轮廓坐标将写入到 {key}_{contour_key_postfix} 的值。
offset_key – GenerateInstanceContour 中使用的偏移量的键。
min_num_points – 假定如果创建的轮廓点数不大于指定值，则不构成轮廓。默认为 3。
level – 可选。在数组中查找轮廓的值。默认情况下，级别设置为 (max(image) + min(image)) / 2。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.post.dictionary.GenerateInstanceCentroidd(keys, centroid_key_postfix='centroid', offset_key=None, dtype=<class 'int'>, allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.post.array.GenerateInstanceCentroid 的基于字典的封装器。使用 skimage.measure.centroid 生成实例质心。

参数:

keys – 需要进行变换的相应项的键。
centroid_key_postfix – 输出质心坐标将写入到 {key}_{centroid_key_postfix} 的值。
offset_key – GenerateInstanceCentroid 中使用的偏移量的键。
dtype – 输出质点的数据类型。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.post.dictionary.GenerateInstanceTyped(keys, type_info_key='type_info', bbox_key='bbox', seg_pred_key='seg', instance_id_key='id', allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.post.array.GenerateInstanceType 的基于字典的封装器。为每个实例生成实例类型和概率。

参数:

keys (Union[Collection[Hashable], Hashable]) – 需要进行变换的相应项的键。
type_info_key (str) – 输出实例类型和概率将写入到 {type_info_key} 的值。
bbox_key (str) – 边界框的键。
seg_pred_key (str) – 分割预测图的键。
instance_id_key (str) – 实例 ID 的键。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

class monai.apps.pathology.transforms.post.dictionary.Watershedd(keys, mask_key='mask', markers_key=None, connectivity=1, dtype=<class 'numpy.uint8'>, allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.array.Watershed 的基于字典的封装器。使用 skimage.segmentation.watershed 从图像中获取实例分割结果。参阅： https://scikit-image.cn/docs/stable/api/skimage.segmentation.html#skimage.segmentation.watershed。

参数:

keys – 需要进行变换的相应项的键。另请参阅： monai.transforms.MapTransform
mask_key – watershed 中使用的掩膜的键。只有 mask == True 的点才会被标记。
markers_key – watershed 中使用的标记的键。如果为 None（未给出标记），则使用图像的局部最小值作为标记。
connectivity – 与图像维度相同的数组，其非零元素表示连接的邻居。遵循 scipy 约定，默认为与图像维度相同的单连接数组。
dtype – 要转换的目标数据内容类型。默认为 np.uint8。
allow_missing_keys – 如果缺少键，不引发异常。

引发:

ValueError – 当 image 形状不是 [1, H, W] 时。
ValueError – 当 mask 形状不是 [1, H, W] 时。

class monai.apps.pathology.transforms.post.dictionary.GenerateWatershedMaskd(keys, mask_key='mask', activation='softmax', threshold=None, min_object_size=10, dtype=<class 'numpy.uint8'>, allow_missing_keys=False)[source]#

monai.apps.pathology.transforms.array.GenerateWatershedMask 的基于字典的封装器。

参数:

keys – 需要进行变换的相应项的键。
mask_key – 掩膜将写入到 {mask_key} 的值。
activation – 应用于核类型分支的激活层。可以是“softmax”或“sigmoid”字符串，或任何可调用对象。默认为“softmax”。
threshold – 如果不为 None，则使用指定的阈值将浮点值二值化为整数 0 或 1。
min_object_size – 移除小于此尺寸的对象。默认为 10。
dtype – 要转换的目标数据内容类型，默认为 np.uint8。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.post.dictionary.GenerateInstanceBorderd(mask_key='mask', hover_map_key='hover_map', border_key='border', kernel_size=21, dtype=<class 'numpy.float32'>)[source]#

基于字典的 monai.apps.pathology.transforms.array.GenerateInstanceBorder 包装器。

参数:

mask_key (str) – 存储分水岭掩码的输入键。默认为 “mask”。
hover_map_key (str) – 存储悬停图的输入键。默认为 “hover_map”。
border_key (str) – 写入实例边界图的输出键。默认为 “border”。
kernel_size (int) – Sobel 核的大小。默认为 21。
dtype (Union[dtype, type, str, None]) – 要转换的目标数据内容类型，默认为 np.float32。
allow_missing_keys – 如果缺少键，不引发异常。

引发:

ValueError – 当 hover_map 只有一个值时。
ValueError – 当 sobel gradient map 只有一个值时。

class monai.apps.pathology.transforms.post.dictionary.GenerateDistanceMapd(mask_key='mask', border_key='border', dist_map_key='dist_map', smooth_fn=None, dtype=<class 'numpy.float32'>)[source]#

基于字典的 monai.apps.pathology.transforms.array.GenerateDistanceMap 包装器。

参数:

mask_key – 存储分水岭掩码的输入键。默认为 “mask”。
border_key – 存储实例边界图的输入键。默认为 “border”。
dist_map_key – 写入距离图的输出键。默认为 “dist_map”。
smooth_fn – 距离图的平滑函数，可以是任何可调用对象。如果未提供，则使用 monai.transforms.GaussianSmooth()。
dtype – 要转换的目标数据内容类型，默认为 np.float32。

class monai.apps.pathology.transforms.post.dictionary.GenerateWatershedMarkersd(mask_key='mask', border_key='border', markers_key='markers', threshold=0.4, radius=2, min_object_size=10, postprocess_fn=None, dtype=<class 'numpy.uint8'>)[source]#

基于字典的 monai.apps.pathology.transforms.array.GenerateWatershedMarkers 包装器。

参数:

mask_key – 存储分水岭掩码的输入键。默认为 “mask”。
border_key – 存储实例边界图的输入键。默认为 “border”。
markers_key – 写入标记的输出键。默认为 “markers”。
threshold – 使用指定的阈值将实例边界图的浮点值阈值化为整型 0 或 1。它将不确定区域变为 1，其他区域变为 0。默认为 0.4。
radius – opening 中使用的圆盘形足迹的半径。默认为 2。
min_object_size – 移除小于此尺寸的对象。默认为 10。
postprocess_fn – 对标记执行额外的后处理转换。默认为 None。
dtype – 要转换的目标数据内容类型，默认为 np.uint8。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.pathology.transforms.post.dictionary.HoVerNetInstanceMapPostProcessingd(nuclear_prediction_key='nucleus_prediction', hover_map_key='horizontal_vertical', instance_info_key='instance_info', instance_map_key='instance_map', activation='softmax', mask_threshold=None, min_object_size=10, sobel_kernel_size=5, distance_smooth_fn=None, marker_threshold=0.4, marker_radius=2, marker_postprocess_fn=None, watershed_connectivity=1, min_num_points=3, contour_level=None, device=None)[source]#

基于字典的 monai.apps.pathology.transforms.post.array.HoVerNetInstanceMapPostProcessing 包装器。用于 HoVerNet 模型生成实例分割图的后处理转换。它生成实例分割图以及包含每个实例的质心、边界框和轮廓的字典。

参数:

nuclear_prediction_key – 用于 HoVerNet NP（核预测）分支的键。默认为 HoVerNetBranch.NP。
hover_map_key – 用于 HoVerNet NC（核预测）分支的键。默认为 HoVerNetBranch.HV。
instance_info_key – 写入实例信息（轮廓、边界框和质心）的输出键。默认为 “instance_info”。
instance_map_key – 写入实例图的输出键。默认为 “instance_map”。
activation – 应用于输入概率图的激活层。可以是“softmax”或“sigmoid”字符串，或任何可调用对象。默认为“softmax”。
mask_threshold – 用于二值化概率图生成掩膜的浮点值。
min_object_size – 移除小于此尺寸的对象。默认为 10。
sobel_kernel_size – GenerateInstanceBorder 中使用的 Sobel 核的大小。默认为 5。
distance_smooth_fn – 距离图的平滑函数。如果未提供，将使用 monai.transforms.intensity.GaussianSmooth()。
marker_threshold – 用于二值化标记的实例边界图的浮点值。它将不确定区域变为 1，其他区域变为 0。默认为 0.4。
marker_radius – 用于标记的 opening 中使用的圆盘形足迹的半径。默认为 2。
marker_postprocess_fn – 分水岭标记的后处理函数。如果未提供，将使用 monai.transforms.post.FillHoles()。
watershed_connectivity – skimage.segmentation.watershed 的 connectivity 参数。
min_num_points – 被视为轮廓的最小点数。默认为 3。
contour_level – skimage.measure.find_contours 在数组中查找轮廓的可选值。如果未提供，则将级别设置为 (max(image) + min(image)) / 2。
device – 放置输出 Tensor 数据的目标设备。

class monai.apps.pathology.transforms.post.dictionary.HoVerNetNuclearTypePostProcessingd(type_prediction_key='type_prediction', instance_info_key='instance_info', instance_map_key='instance_map', type_map_key='type_map', activation='softmax', threshold=None, return_type_map=True, device=None)[source]#

基于字典的 monai.apps.pathology.transforms.post.array.HoVerNetNuclearTypePostProcessing 包装器。它使用关于核类型（值和概率）的信息更新输入的实例信息字典。如果请求 (return_type_map=True)，它还会生成像素级别的类型图。

参数:

type_prediction_key – 用于 HoVerNet NC（类型预测）分支的键。默认为 HoVerNetBranch.NC。
instance_info_key – 存储实例信息（轮廓、边界框和质心）的键。默认为 “instance_info”。
instance_map_key – 存储实例图的键。默认为 “instance_map”。
type_map_key – 写入类型图的输出键。默认为 “type_map”。
device – 放置输出 Tensor 数据的目标设备。

检测#

难例负样本采样器#

此脚本中的函数改编自 nnDetection, MIC-DKFZ/nnDetection

class monai.apps.detection.utils.hard_negative_sampler.HardNegativeSampler(batch_size_per_image, positive_fraction, min_neg=1, pool_size=10)[source]#

HardNegativeSampler 用于抑制分类任务中的假阳性率。在训练期间，它选择具有高预测分数的负样本。

训练流程描述如下：1) 前向传播网络并获取所有样本的预测分数（分类概率/logits）；2) 使用难例负样本采样器选择具有高预测分数的负样本和一些正样本；3) 计算所选样本的分类损失；4) 进行反向传播。

参数:

batch_size_per_image (int) – 每张图像随机选择的训练样本数。
positive_fraction (float) – 所选样本中正元素的百分比。
min_neg (int) – 如果可能，要选择的最小负样本数。
pool_size (float) – 当我们需要 num_neg 个难例负样本时，它们将从具有最高预测分数的 num_neg * pool_size 个负样本中随机选择。更大的 pool_size 提供了更多的随机性，但选择的负样本会“不那么难”，即预测分数较低的负样本。

get_num_neg(negative, num_pos)[source]#

采样足够的负样本以填满 self.batch_size_per_image

参数:

negative (Tensor) – 正样本的索引。
num_pos (int) – 要抽取的正样本数。

返回类型:

int

返回:

负样本数

get_num_pos(positive)[source]#

要抽取的正样本数

参数:: positive (Tensor) – 正样本的索引。
返回类型:: int
返回:: 正样本数

select_positives(positive, num_pos, labels)[source]#

选择正样本

参数:

positive (Tensor) – 正样本的索引，大小为 (P,)，其中 P 是正样本数。
num_pos (int) – 要采样的正样本数。
labels (Tensor) – 所有样本的标签，大小为 (A,)，其中 A 是样本数。

返回类型:

Tensor

返回:

要选择的正样本的二进制掩码，大小为 (A,)，: 其中 A 是一张图像中的样本数。

select_samples_img_list(target_labels, fg_probs)[source]#

从每张图像的列表样本中选择正样本和难例负样本。硬负样本采样器将独立应用于每张图像。

参数:

target_labels (list[Tensor]) – 每张图像的标签列表。对于批次中的图像 i，target_labels[i] 是一个大小为 (A_i,) 的 Tensor，其中 A_i 是图像 i 中的样本数。正样本具有正标签，负样本具有标签 0。
fg_probs (list[Tensor]) – 每张图像的最大前景概率列表。对于批次中的图像 i，target_labels[i] 是一个大小为 (A_i,) 的 Tensor，其中 A_i 是图像 i 中的样本数。

返回类型:

tuple[list[Tensor], list[Tensor]]

返回:

正样本的二进制掩码列表
负样本的二进制掩码列表

示例

sampler = HardNegativeSampler(
    batch_size_per_image=6, positive_fraction=0.5, min_neg=1, pool_size=2
)
# two images with different number of samples
target_labels = [ torch.tensor([0,1]), torch.tensor([1,0,2,1])]
fg_probs = [ torch.rand(2), torch.rand(4)]
pos_idx_list, neg_idx_list = sampler.select_samples_img_list(target_labels, fg_probs)

select_samples_per_img(labels_per_img, fg_probs_per_img)[source]#

从样本中选择正样本和难例负样本。

参数:

labels_per_img (Tensor) – 标签，大小为 (A,)。正样本具有正标签，负样本具有标签 0。
fg_probs_per_img (Tensor) – 最大前景概率，大小为 (A,)。

返回类型:

tuple[Tensor, Tensor]

返回:

正样本的二进制掩码，大小为 (A,)
负样本的二进制掩码，大小为 (A,)

示例

sampler = HardNegativeSampler(
    batch_size_per_image=6, positive_fraction=0.5, min_neg=1, pool_size=2
)
# two images with different number of samples
target_labels = torch.tensor([1,0,2,1])
fg_probs = torch.rand(4)
pos_idx, neg_idx = sampler.select_samples_per_img(target_labels, fg_probs)

class monai.apps.detection.utils.hard_negative_sampler.HardNegativeSamplerBase(pool_size=10)[source]#

难例负样本采样器的基类。

难例负样本采样器用于抑制分类任务中的假阳性率。在训练期间，它选择具有高预测分数的负样本。

参数:: pool_size (float) – 当我们需要 num_neg 个难例负样本时，它们将从具有最高预测分数的 num_neg * pool_size 个负样本中随机选择。更大的 pool_size 提供了更多的随机性，但选择的负样本会“不那么难”，即预测分数较低的负样本。

select_negatives(negative, num_neg, fg_probs)[source]#

选择难例负样本。

参数:

negative (Tensor) – 所有负样本的索引，大小为 (P,)，其中 P 是负样本数。
num_neg (int) – 要采样的负样本数。
fg_probs (Tensor) – 每个样本在所有类别中的最大前景预测分数（概率），大小为 (A,)，其中 A 是样本数。

返回类型:

Tensor

返回:

要选择的负样本的二进制掩码，大小为 (A,)，: 其中 A 是一张图像中的样本数。

RetinaNet 网络#

此脚本的一部分改编自 pytorch/vision

class monai.apps.detection.networks.retinanet_network.RetinaNet(spatial_dims, num_classes, num_anchors, feature_extractor, size_divisible=1, use_list_output=False)[source]#

RetinaNet 中使用的网络。

它接受图像张量作为输入，并输出 1) 一个字典 head_outputs。 head_outputs[self.cls_key] 是预测的分类图，一个 Tensor 列表。 head_outputs[self.box_reg_key] 是预测的边界框回归图，一个 Tensor 列表。或者 2) 一个包含 2N 个张量的列表 head_outputs，其中前 N 个张量是预测的分类图，后 N 个张量是预测的边界框回归图。

参数:

spatial_dims – 图像的空间维度数。我们支持 2D 和 3D 图像。
num_classes – 模型的输出类别数（不包括背景）。
num_anchors – 每个位置的锚点数量。
feature_extractor – 从输入图像中输出特征图的网络，每个特征图对应不同的分辨率。其输出格式可以是 Tensor、Dict[Any, Tensor] 或 Sequence[Tensor]。它可以是 resnet_fpn_feature_extractor(*args, **kwargs) 的输出。
size_divisible – 网络输入的空间尺寸应该能被 size_divisible 整除，由 feature_extractor 决定。
use_list_output – 默认为 False。如果为 False，网络输出一个字典 head_outputs， head_outputs[self.cls_key] 是预测的分类图，一个 Tensor 列表。 head_outputs[self.box_reg_key] 是预测的边界框回归图，一个 Tensor 列表。如果为 True，网络输出一个包含 2N 个张量的列表 head_outputs，其中前 N 个张量是预测的分类图，后 N 个张量是预测的边界框回归图。

示例

from monai.networks.nets import resnet
spatial_dims = 3  # 3D network
conv1_t_stride = (2,2,1)  # stride of first convolutional layer in backbone
backbone = resnet.ResNet(
    spatial_dims = spatial_dims,
    block = resnet.ResNetBottleneck,
    layers = [3, 4, 6, 3],
    block_inplanes = resnet.get_inplanes(),
    n_input_channels= 1,
    conv1_t_stride = conv1_t_stride,
    conv1_t_size = (7,7,7),
)
# This feature_extractor outputs 4-level feature maps.
# number of output feature maps is len(returned_layers)+1
returned_layers = [1,2,3]  # returned layer from feature pyramid network
feature_extractor = resnet_fpn_feature_extractor(
    backbone = backbone,
    spatial_dims = spatial_dims,
    pretrained_backbone = False,
    trainable_backbone_layers = None,
    returned_layers = returned_layers,
)
# This feature_extractor requires input image spatial size
# to be divisible by (32, 32, 16).
size_divisible = tuple(2*s*2**max(returned_layers) for s in conv1_t_stride)
model = RetinaNet(
    spatial_dims = spatial_dims,
    num_classes = 5,
    num_anchors = 6,
    feature_extractor=feature_extractor,
    size_divisible = size_divisible,
).to(device)
result = model(torch.rand(2, 1, 128,128,128))
cls_logits_maps = result["classification"]  # a list of len(returned_layers)+1 Tensor
box_regression_maps = result["box_regression"]  # a list of len(returned_layers)+1 Tensor

forward(images)[source]#

它接受图像张量作为输入，并在 head_outputs 中输出预测的分类图和预测的边界框回归图。

参数:: images (Tensor) – 输入图像，大小为 (B, img_channels, H, W) 或 (B, img_channels, H, W, D)。
返回类型:: Any
返回:: 1) 如果 self.use_list_output 为 False，输出一个字典 head_outputs，包含 self.cls_key 和 self.box_reg_key 等键。 head_outputs[self.cls_key] 是预测的分类图，一个 Tensor 列表。 head_outputs[self.box_reg_key] 是预测的边界框回归图，一个 Tensor 列表。2) 如果 self.use_list_output 为 True，输出一个包含 2N 个张量的列表 head_outputs，其中前 N 个张量是预测的分类图，后 N 个张量是预测的边界框回归图。

class monai.apps.detection.networks.retinanet_network.RetinaNetClassificationHead(in_channels, num_anchors, num_classes, spatial_dims, prior_probability=0.01)[source]#

用于 RetinaNet 的分类头。

此头接受特征图列表作为输入，并输出分类图列表。每个输出图与对应的输入特征图具有相同的空间大小，并且输出通道数是 num_anchors * num_classes。

参数:

in_channels (int) – 输入特征的通道数。
num_anchors (int) – 要预测的锚点数。
num_classes (int) – 要预测的类别数。
spatial_dims (int) – 网络的空间维度，应为 2 或 3。
prior_probability (float) – 初始化分类卷积层的先验概率。

forward(x)[source]#

它接受特征图列表作为输入，并输出分类图列表。每个输出分类图与对应的输入特征图具有相同的空间大小，并且输出通道数是 num_anchors * num_classes。

参数:: x (list[Tensor]) – 特征图列表，x[i] 是一个 (B, in_channels, H_i, W_i) 或 (B, in_channels, H_i, W_i, D_i) 的 Tensor。
返回类型:: list[Tensor]
返回:: cls_logits_maps，分类图列表。cls_logits_maps[i] 是一个 (B, num_anchors * num_classes, H_i, W_i) 或 (B, num_anchors * num_classes, H_i, W_i, D_i) 的 Tensor。

class monai.apps.detection.networks.retinanet_network.RetinaNetRegressionHead(in_channels, num_anchors, spatial_dims)[source]#

用于 RetinaNet 的回归头。

此头接受特征图列表作为输入，并输出边界框回归图列表。每个输出边界框回归图与对应的输入特征图具有相同的空间大小，并且输出通道数是 num_anchors * 2 * spatial_dims。

参数:

in_channels (int) – 输入特征的通道数。
num_anchors (int) – 要预测的锚点数。
spatial_dims (int) – 网络的空间维度，应为 2 或 3。

forward(x)[source]#

它接受特征图列表作为输入，并输出边界框回归图列表。每个输出边界框回归图与对应的输入特征图具有相同的空间大小，并且输出通道数是 num_anchors * 2 * spatial_dims。

参数:: x (list[Tensor]) – 特征图列表，x[i] 是一个 (B, in_channels, H_i, W_i) 或 (B, in_channels, H_i, W_i, D_i) 的 Tensor。
返回类型:: list[Tensor]
返回:: box_regression_maps，边界框回归图列表。cls_logits_maps[i] 是一个 (B, num_anchors * 2 * spatial_dims, H_i, W_i) 或 (B, num_anchors * 2 * spatial_dims, H_i, W_i, D_i) 的 Tensor。

monai.apps.detection.networks.retinanet_network.resnet_fpn_feature_extractor(backbone, spatial_dims, pretrained_backbone=False, returned_layers=(1, 2, 3), trainable_backbone_layers=None)[source]#

使用 ResNet-FPN 主干构建特征提取网络，用作 RetinaNet 中的 feature_extractor。

参考：“Focal Loss for Dense Object Detection”。

返回的 feature_extractor 网络接受图像张量作为输入，并输出一个将字符串映射到提取的特征图 (Tensor) 的字典。

返回的 feature_extractor 的输入预计是张量列表，每个张量的形状为 [C, H, W] 或 [C, H, W, D]，每张图像一个。不同图像可以有不同的大小。

参数:

backbone – 一个 ResNet 模型，用作主干网络。
spatial_dims – 图像的空间维度数。我们支持 2D 和 3D 图像。
pretrained_backbone – 主干网络是否已预训练。
returned_layers – 用于提取特征图的返回层。每个返回层应在 [1,4] 范围内。len(returned_layers)+1 将是提取的特征图数量。额外追加了一个最大池化层 LastLevelMaxPool()。
trainable_backbone_layers – 从最终块开始的可训练（未冻结）resnet 层数。有效值介于 0 到 5 之间，5 表示所有主干层都可训练。当 pretrained_backbone 为 False 时，此值设置为 5。当 pretrained_backbone 为 True 时，如果传入 None（默认值），此值设置为 3。

示例

from monai.networks.nets import resnet
spatial_dims = 3 # 3D network
backbone = resnet.ResNet(
    spatial_dims = spatial_dims,
    block = resnet.ResNetBottleneck,
    layers = [3, 4, 6, 3],
    block_inplanes = resnet.get_inplanes(),
    n_input_channels= 1,
    conv1_t_stride = (2,2,1),
    conv1_t_size = (7,7,7),
)
# This feature_extractor outputs 4-level feature maps.
# number of output feature maps is len(returned_layers)+1
feature_extractor = resnet_fpn_feature_extractor(
    backbone = backbone,
    spatial_dims = spatial_dims,
    pretrained_backbone = False,
    trainable_backbone_layers = None,
    returned_layers = [1,2,3],
)
model = RetinaNet(
    spatial_dims = spatial_dims,
    num_classes = 5,
    num_anchors = 6,
    feature_extractor=feature_extractor,
    size_divisible = 32,
).to(device)

RetinaNet 检测器#

此脚本的一部分改编自 pytorch/vision

class monai.apps.detection.networks.retinanet_detector.RetinaNetDetector(network, anchor_generator, box_overlap_metric=<function box_iou>, spatial_dims=None, num_classes=None, size_divisible=1, cls_key='classification', box_reg_key='box_regression', debug=False)[source]#

Retinanet 检测器，未来可扩展到其他基于锚点的单阶段边界框检测器。可以在 retinanet_resnet50_fpn_detector() 的源代码中找到构建示例。

模型的输入预计是张量列表，每个张量的形状为 (C, H, W) 或 (C, H, W, D)，每张图像一个，并且应在 0-1 范围内。不同图像可以有不同的大小。它也可以是一个大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 Tensor。在这种情况下，所有图像具有相同的大小。

模型的行为根据其处于训练模式还是评估模式而变化。

在训练期间，模型期望输入张量以及一个包含以下内容的 targets（字典列表）：

boxes (FloatTensor[N, 4] 或 FloatTensor[N, 6])： StandardMode 中的地面真值边界框，即 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax] 格式，其中 0 <= xmin < xmax <= H, 0 <= ymin < ymax <= W, 0 <= zmin < zmax <= D。
labels：每个地面真值边界框的类别标签

模型在训练期间返回一个包含分类损失和回归损失的 Dict[str, Tensor]。保存模型时，只有 self.network 包含可训练参数，需要保存。

在推理期间，模型仅需要输入张量，并返回后处理的预测结果作为 List[Dict[Tensor]]，每个输入图像一个。Dict 的字段如下：

boxes (FloatTensor[N, 4] 或 FloatTensor[N, 6])： StandardMode 中的预测边界框，即 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax] 格式，其中 0 <= xmin < xmax <= H, 0 <= ymin < ymax <= W, 0 <= zmin < zmax <= D。
labels (Int64Tensor[N])：每张图像的预测标签。
labels_scores (Tensor[N])：每个预测的分数。

参数:

network – 一个接受大小为 (B, C, H, W) 或 (B, C, H, W, D) 的图像 Tensor 作为输入并输出一个字典 Dict[str, List[Tensor]] 或 Dict[str, Tensor] 的网络。
anchor_generator – 锚点生成器。
box_overlap_metric – 计算两组边界框之间重叠度的函数，默认为交并比 (IoU)。
debug – 是否打印内部参数，用于调试和参数调整。

注意

输入参数 network 可以是 monai.apps.detection.networks.retinanet_network.RetinaNet(*) 对象，但任何满足以下规则的网络都是有效的输入 network。

它应具有包括 spatial_dims、num_classes、cls_key、box_reg_key、num_anchors、size_divisible 在内的属性。
- spatial_dims (int) 是网络的空间维度，我们支持 2D 和 3D。
- num_classes (int) 是类别数，不包括背景。
- size_divisible (int 或 Sequence[int]) 是对输入图像形状的期望。网络需要输入空间尺寸能被 size_divisible 整除，长度应为 2 或 3。
- cls_key (str) 是输出字典中表示分类的键。
- box_reg_key (str) 是输出字典中表示边界框回归的键。
- num_anchors (int) 是每个位置的锚点形状数量。它应等于 self.anchor_generator.num_anchors_per_location()[0]。
如果网络没有这些属性，用户需要为检测器提供它们。
其输入应为大小为 (B, C, H, W) 或 (B, C, H, W, D) 的图像 Tensor。
关于其输出 head_outputs，它应该是一个张量列表或一个 str: List[Tensor] 的字典。
- 如果是一个字典，它需要至少有两个键：network.cls_key 和 network.box_reg_key，分别表示预测的分类图和边界框回归图。head_outputs[network.cls_key] 应该是一个 List[Tensor] 或 Tensor。每个 Tensor 表示一个分辨率级别的分类 logits 图，大小为 (B, num_classes*num_anchors, H_i, W_i) 或 (B, num_classes*num_anchors, H_i, W_i, D_i)。head_outputs[network.box_reg_key] 应该是一个 List[Tensor] 或 Tensor。每个 Tensor 表示一个分辨率级别的边界框回归图，大小为 (B, 2*spatial_dims*num_anchors, H_i, W_i) 或 (B, 2*spatial_dims*num_anchors, H_i, W_i, D_i)。len(head_outputs[network.cls_key]) == len(head_outputs[network.box_reg_key])。
- 如果是一个包含 2N 个张量的列表，前 N 个张量应是预测的分类图，后 N 个张量应是预测的边界框回归图。

示例

# define a naive network
import torch
class NaiveNet(torch.nn.Module):
    def __init__(self, spatial_dims: int, num_classes: int):
        super().__init__()
        self.spatial_dims = spatial_dims
        self.num_classes = num_classes
        self.size_divisible = 2
        self.cls_key = "cls"
        self.box_reg_key = "box_reg"
        self.num_anchors = 1
    def forward(self, images: torch.Tensor):
        spatial_size = images.shape[-self.spatial_dims:]
        out_spatial_size = tuple(s//self.size_divisible for s in spatial_size)  # half size of input
        out_cls_shape = (images.shape[0],self.num_classes*self.num_anchors) + out_spatial_size
        out_box_reg_shape = (images.shape[0],2*self.spatial_dims*self.num_anchors) + out_spatial_size
        return {self.cls_key: [torch.randn(out_cls_shape)], self.box_reg_key: [torch.randn(out_box_reg_shape)]}

# create a RetinaNetDetector detector
spatial_dims = 3
num_classes = 5
anchor_generator = monai.apps.detection.utils.anchor_utils.AnchorGeneratorWithAnchorShape(
    feature_map_scales=(1, ), base_anchor_shapes=((8,) * spatial_dims)
)
net = NaiveNet(spatial_dims, num_classes)
detector = RetinaNetDetector(net, anchor_generator)

# only detector.network may contain trainable parameters.
optimizer = torch.optim.SGD(
    detector.network.parameters(),
    1e-3,
    momentum=0.9,
    weight_decay=3e-5,
    nesterov=True,
)
torch.save(detector.network.state_dict(), 'model.pt')  # save model
detector.network.load_state_dict(torch.load('model.pt'))  # load model

compute_anchor_matched_idxs(anchors, targets, num_anchor_locs_per_level)[source]#

计算 targets 中锚点和地面真值 (gt) 边界框之间的匹配索引。output[k][i] 表示图像 k 中 anchor[i] 的匹配 gt 索引。假设图像 k 有 M 个 gt 边界框。output[k][i] 值的范围是 [-2, -1, 0, ..., M-1]。[0, M - 1] 表示此锚点与 gt 边界框匹配，而负值表示未匹配。

参数:

anchors (list[Tensor]) – Tensor 列表。每个 Tensor 表示每张图像的锚点，大小为 (sum(HWA), 2*spatial_dims) 或 (sum(HWDA), 2*spatial_dims)。A = self.num_anchors_per_loc。
targets (list[dict[str, Tensor]]) – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
num_anchor_locs_per_level (Sequence[int]) – 每个元素表示此级别的 HW 或 HWD。

返回类型:

list[Tensor]

返回:

匹配索引 matched_idxs_per_image (Tensor[int64]) 列表，Tensor 大小为 (sum(HWA),) 或 (sum(HWDA),)。假设有 M 个 gt 边界框。matched_idxs_per_image[i] 是 [0, M - 1] 中的匹配 gt 索引，或表示锚点 i 未匹配的负值。BELOW_LOW_THRESHOLD = -1，BETWEEN_THRESHOLDS = -2

compute_box_loss(box_regression, targets, anchors, matched_idxs)[source]#

计算边界框回归损失。

参数:

box_regression (Tensor) – 边界框回归结果，大小为 (B, sum(HWA), 2*self.spatial_dims)。
targets (list[dict[str, Tensor]]) – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
anchors (list[Tensor]) – Tensor 列表。每个 Tensor 表示每张图像的锚点，大小为 (sum(HWA), 2*spatial_dims) 或 (sum(HWDA), 2*spatial_dims)。A = self.num_anchors_per_loc。
matched_idxs (list[Tensor]) – 匹配索引列表。每个元素的大小为 (sum(HWA),) 或 (sum(HWDA),)。

返回类型:

Tensor

返回:

边界框回归损失。

compute_cls_loss(cls_logits, targets, matched_idxs)[source]#

计算分类损失。

参数:

cls_logits (Tensor) – 分类 logits，大小为 (B, sum(HW(D)A), self.num_classes)。
targets (list[dict[str, Tensor]]) – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
matched_idxs (list[Tensor]) – 匹配索引列表。每个元素的大小为 (sum(HWA),) 或 (sum(HWDA),)。

返回类型:

Tensor

返回:

分类损失。

compute_loss(head_outputs_reshape, targets, anchors, num_anchor_locs_per_level)[source]#

计算损失。

参数:

head_outputs_reshape (dict[str, Tensor]) – reshape 后的 head_outputs。head_output_reshape[self.cls_key] 是一个大小为 (B, sum(HW(D)A), self.num_classes) 的 Tensor。head_output_reshape[self.box_reg_key] 是一个大小为 (B, sum(HW(D)A), 2*self.spatial_dims) 的 Tensor。
targets (list[dict[str, Tensor]]) – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
anchors (list[Tensor]) – Tensor 列表。每个 Tensor 表示每张图像的锚点，大小为 (sum(HWA), 2*spatial_dims) 或 (sum(HWDA), 2*spatial_dims)。A = self.num_anchors_per_loc。

返回类型:

dict[str, Tensor]

返回:

包含几种损失的字典。

forward(input_images, targets=None, use_inferer=False)[source]#

在训练期间返回一个损失字典，或在推理期间返回一个预测的边界框和标签字典列表。

参数:

input_images – 模型的输入预计是张量列表，每个张量的形状为 (C, H, W) 或 (C, H, W, D)，每张图像一个，并且应在 0-1 范围内。不同图像可以有不同的大小。它也可以是一个大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 Tensor。在这种情况下，所有图像具有相同的大小。
targets – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框（可选）。
use_inferer – 是否使用 self.inferer（一个滑动窗口推理器）进行推理。如果为 False，将直接前向传播网络。如果为 True，将使用 self.inferer，并且需要之前已调用 self.set_sliding_window_inferer(*args)。

返回:

如果是训练模式，将返回一个至少有两个键的字典，包括 self.cls_key 和 self.box_reg_key，分别表示分类损失和边界框回归损失。

如果是评估模式，将返回一个检测结果列表。每个元素对应 input_images 中的一张图像，是一个至少有三个键的字典，包括 self.target_box_key、self.target_label_key、self.pred_score_key，分别表示预测的边界框、分类标签和分类分数。

generate_anchors(images, head_outputs)[source]#

生成锚点并将其存储在 self.anchors: List[Tensor] 中。我们只在没有存储的锚点，或者新来的图像与 self.previous_image_shape 形状不同时生成锚点。

参数:

images (Tensor) – 输入图像，一个 (B, C, H, W) 或 (B, C, H, W, D) 的 Tensor。
head_outputs (dict[str, list[Tensor]]) – head_outputs。head_output_reshape[self.cls_key] 是一个大小为 (B, sum(HW(D)A), self.num_classes) 的 Tensor。head_output_reshape[self.box_reg_key] 是一个大小为 (B, sum(HW(D)A), 2*self.spatial_dims) 的 Tensor。

返回类型:

None

get_box_train_sample_per_image(box_regression_per_image, targets_per_image, anchors_per_image, matched_idxs_per_image)[source]#

从一张图像中获取样本用于计算边界框回归损失。

参数:

box_regression_per_image (Tensor) – 单张图像的边界框回归结果，大小为 (sum(HWA), 2*self.spatial_dims)。
targets_per_image (dict[str, Tensor]) – 一个至少有两个键的字典：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
anchors_per_image (Tensor) – 单张图像的锚点，大小为 (sum(HWA), 2*spatial_dims) 或 (sum(HWDA), 2*spatial_dims)。A = self.num_anchors_per_loc。
matched_idxs_per_image (Tensor) – 匹配索引，大小为 (sum(HWA),) 或 (sum(HWDA),)。

返回类型:

tuple[Tensor, Tensor]

返回:

单张图像中用于计算边界框回归损失的配对预测样本和 GT 样本。

get_cls_train_sample_per_image(cls_logits_per_image, targets_per_image, matched_idxs_per_image)[source]#

从一张图像中获取样本用于计算分类损失。

参数:

cls_logits_per_image (Tensor) – 单张图像的分类 logits，大小为 (sum(HWA), self.num_classes)。
targets_per_image (dict[str, Tensor]) – 一个至少有两个键的字典：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
matched_idxs_per_image (Tensor) – 匹配索引，Tensor 大小为 (sum(HWA),) 或 (sum(HWDA),)。假设有 M 个 gt 边界框。matched_idxs_per_image[i] 是 [0, M - 1] 中的匹配 gt 索引，或表示锚点 i 未匹配的负值。BELOW_LOW_THRESHOLD = -1，BETWEEN_THRESHOLDS = -2

返回类型:

tuple[Tensor, Tensor]

返回:

单张图像中用于计算分类损失的配对预测样本和 GT 样本。

postprocess_detections(head_outputs_reshape, anchors, image_sizes, num_anchor_locs_per_level, need_sigmoid=True)[source]#

后处理从分类 logits 和边界框回归中生成检测结果。使用 self.box_selector 为每张图像选择最终输出边界框。

参数:

head_outputs_reshape (dict[str, Tensor]) – reshape 后的 head_outputs。head_output_reshape[self.cls_key] 是一个大小为 (B, sum(HW(D)A), self.num_classes) 的 Tensor。head_output_reshape[self.box_reg_key] 是一个大小为 (B, sum(HW(D)A), 2*self.spatial_dims) 的 Tensor。
targets – dict 列表。每个 dict 有两个键：self.target_box_key 和 self.target_label_key，图像中存在的地面真值边界框。
anchors (list[Tensor]) – Tensor 列表。每个 Tensor 表示每张图像的锚点，大小为 (sum(HWA), 2*spatial_dims) 或 (sum(HWDA), 2*spatial_dims)。A = self.num_anchors_per_loc。

返回类型:

list[dict[str, Tensor]]

返回:

dict 列表，每个 dict 对应图像上的检测结果。

set_atss_matcher(num_candidates=4, center_in_gt=False)[source]#

用于训练。设置 ATSS 匹配器，将锚点与地面真值边界框匹配。

参数:

num_candidates (int) – 用于选择候选位置的数量。值越小，匹配器阈值越高，匹配到的候选数越少。
center_in_gt (bool) – 如果为 False（默认），匹配的锚点中心点无需位于地面真值边界框内。对于小对象建议设置为 False。如果为 True，将导致匹配器更严格，匹配到的候选数更少。

返回类型:

None

set_balanced_sampler(batch_size_per_image, positive_fraction)[source]#

用于训练。设置 torchvision 平衡采样器，用于采样部分锚点进行训练。

参数:

batch_size_per_image (int) – 每张图像要选择的元素数。
positive_fraction (float) – 每批次正元素的百分比。

返回类型:

None

set_box_coder_weights(weights)[source]#

设置边界框编码器的权重。

参数:: weights (tuple[float]) – 长度为 2*self.spatial_dims 的列表/元组。
返回类型:: None

set_box_regression_loss(box_loss, encode_gt, decode_pred)[source]#

用于训练。设置边界框回归损失。

参数:

box_loss (Module) – 边界框回归的损失模块。
encode_gt (bool) – 如果为 True，将在计算损失之前将地面真值边界框编码为目标边界框回归。对于 L1 损失应为 True，对于 GIoU 损失应为 False。
decode_pred (bool) – 如果为 True，将在计算损失之前将预测的边界框回归解码为预测的边界框。对于 L1 损失应为 False，对于 GIoU 损失应为 True。

示例

detector.set_box_regression_loss(
    torch.nn.SmoothL1Loss(beta=1.0 / 9, reduction="mean"),
    encode_gt = True, decode_pred = False
)
detector.set_box_regression_loss(
    monai.losses.giou_loss.BoxGIoULoss(reduction="mean"),
    encode_gt = False, decode_pred = True
)

返回类型:: None

set_box_selector_parameters(score_thresh=0.05, topk_candidates_per_level=1000, nms_thresh=0.5, detections_per_img=300, apply_sigmoid=True)[source]#

用于推理。设置推理期间用于边界框选择的参数。边界框选择按照以下步骤执行：

对于每个级别，丢弃分数低于 self.score_thresh 的边界框。
对于每个级别，保留分数最高的 self.topk_candidates_per_level 个边界框。
对于整个图像，对边界框执行非极大值抑制 (NMS)，重叠阈值为 nms_thresh。
对于整个图像，保留分数最高的 self.detections_per_img 个边界框。

参数:

score_thresh (float) – 分数低于 score_thresh 的边界框将被丢弃。
topk_candidates_per_level (int) – 每个级别保留的最大边界框数。
nms_thresh (float) – NMS 的边界框重叠阈值。
detections_per_img (int) – 每张图像保留的最大边界框数。

返回类型:

None

set_cls_loss(cls_loss)[source]#

用于训练。设置接受 logits 作为输入的分类损失，确保内置了 sigmoid/softmax。

参数:: cls_loss (Module) – 分类的损失模块。

示例

detector.set_cls_loss(torch.nn.BCEWithLogitsLoss(reduction="mean"))
detector.set_cls_loss(FocalLoss(reduction="mean", gamma=2.0))

返回类型:: None

set_hard_negative_sampler(batch_size_per_image, positive_fraction, min_neg=1, pool_size=10)[source]#

用于训练。设置硬负样本采样器，用于采样部分锚点进行训练。

HardNegativeSampler 用于抑制分类任务中的假阳性率。在训练期间，它选择具有高预测分数的负样本。

参数:

batch_size_per_image (int) – 每张图像要选择的元素数。
positive_fraction (float) – 所选样本中正元素的百分比。
min_neg (int) – 如果可能，要选择的最小负样本数。
pool_size (float) – 当我们需要 num_neg 个难例负样本时，它们将从具有最高预测分数的 num_neg * pool_size 个负样本中随机选择。更大的 pool_size 提供了更多的随机性，但选择的负样本会“不那么难”，即预测分数较低的负样本。

返回类型:

None

set_regular_matcher(fg_iou_thresh, bg_iou_thresh, allow_low_quality_matches=True)[source]#

用于训练。设置 torchvision 匹配器，用于将锚点与地面真值边界框匹配。

参数:

fg_iou_thresh (float) – 匹配器的前景 IoU 阈值，如果 IoU > fg_iou_thresh 则视为匹配。
bg_iou_thresh (float) – 匹配器的背景 IoU 阈值，如果 IoU < bg_iou_thresh 则视为不匹配。
allow_low_quality_matches (bool) – 如果为 True，对于只有低质量匹配候选的预测生成额外的匹配。

返回类型:

None

set_sliding_window_inferer(roi_size, sw_batch_size=1, overlap=0.5, mode=constant, sigma_scale=0.125, padding_mode=constant, cval=0.0, sw_device=None, device=None, progress=False, cache_roi_weight_map=False)[source]#: 定义滑动窗口推理器并将其存储到 self.inferer。

set_target_keys(box_key, label_key)[source]#

设置训练 targets 和推理输出的键。在训练期间，执行 self.forward(input_images, targets) 时，box_key 和 label_key 都应是 targets 中的键。在推理期间，它们将是 self.forward(input_images)` 的输出字典中的键。

返回类型:: None

monai.apps.detection.networks.retinanet_detector.retinanet_resnet50_fpn_detector(num_classes, anchor_generator, returned_layers=(1, 2, 3), pretrained=False, progress=True, **kwargs)[source]#

返回一个使用 ResNet-50 作为主干的 RetinaNet 检测器，该主干可以从 Med3D: Transfer Learning for 3D Medical Image Analysis <https://arxiv.org/pdf/1904.00625.pdf> _ 进行预训练。

参数:

num_classes (int) – 模型的输出类别数（不包括背景）。
anchor_generator (AnchorGenerator) – 锚点生成器，
returned_layers (Sequence[int]) – 返回特征图的层。每个返回的层应在 [1,4] 范围内。len(returned_layers)+1 将是提取的特征图数量。附加了一个额外的最大池化层 LastLevelMaxPool()。
pretrained (bool) – 如果为 True，则返回在 23 个医学数据集上预训练的骨干网络。
progress (bool) – 如果为 True，则在 stderr 显示下载进度条。

返回类型:

RetinaNetDetector

返回:

一个以 resnet50 作为骨干网络的 RetinaNetDetector 对象。

示例

# define a naive network
resnet_param = {
    "pretrained": False,
    "spatial_dims": 3,
    "n_input_channels": 2,
    "num_classes": 3,
    "conv1_t_size": 7,
    "conv1_t_stride": (2, 2, 2)
}
returned_layers = [1]
anchor_generator = monai.apps.detection.utils.anchor_utils.AnchorGeneratorWithAnchorShape(
    feature_map_scales=(1, 2), base_anchor_shapes=((8,) * resnet_param["spatial_dims"])
)
detector = retinanet_resnet50_fpn_detector(
    **resnet_param, anchor_generator=anchor_generator, returned_layers=returned_layers
)

Transforms#

monai.apps.detection.transforms.box_ops.apply_affine_to_boxes(boxes, affine)[source]#

此函数将仿射矩阵应用于框。

参数:

boxes (~NdarrayTensor) – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
affine (Union[ndarray, Tensor]) – 应用于框坐标的仿射矩阵，大小为 (spatial_dims+1,spatial_dims+1)。

返回类型:

~NdarrayTensor

返回:

返回仿射变换后的框，与 boxes 具有相同的数据类型，不与 boxes 共享内存。

monai.apps.detection.transforms.box_ops.convert_box_to_mask(boxes, labels, spatial_size, bg_label=-1, ellipse_mask=False)[source]#

将框转换为 int16 掩码图像，其大小与输入图像相同。

参数:

boxes – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
labels – 与 boxes 对应的分类前景(fg)标签，dtype 应为 int，大小为 (N,)。
spatial_size – 图像空间大小。
bg_label – 输出掩码图像的背景标签，确保它小于任何前景标签。
ellipse_mask –
bool。
- 如果为 True，则假定对象形状接近椭圆或椭球体。
- 如果为 False，则假定对象形状接近矩形或立方体，并且很好地占据了边界框。
- 如果用户打算应用随机旋转作为数据增强，我们建议设置 ellipse_mask=True。另请参见 Kalra 等人 “Towards Rotation Invariance in Object Detection”, ICCV 2021。

返回:

int16 数组，大小为 (num_box, H, W)。每个通道代表一个框。
通道 c 中的前景区域强度为 labels[c]。背景强度为 bg_label。

monai.apps.detection.transforms.box_ops.convert_mask_to_box(boxes_mask, bg_label=-1, box_dtype=torch.float32, label_dtype=torch.int64)[source]#

将 int16 掩码图像转换为框，其大小与输入图像相同。

参数:

boxes_mask – int16 数组，大小为 (num_box, H, W)。每个通道代表一个框。通道 c 中的前景区域强度为 labels[c]。背景强度为 bg_label。
bg_label – boxes_mask 的背景标签。
box_dtype – 框的输出 dtype。
label_dtype – 标签的输出 dtype。

返回:

边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
分类前景(fg)标签，dtype 应为 int，大小为 (N,)。

monai.apps.detection.transforms.box_ops.flip_boxes(boxes, spatial_size, flip_axes=None)[source]#

当相应的图像被翻转时翻转框。

参数:

boxes – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
spatial_size – 图像空间大小。
flip_axes – 要翻转的空间轴。默认为 None。默认的 axis=None 将翻转输入数组的所有轴。如果 axis 为负数，则从最后一个轴开始计数到第一个轴。如果 axis 是一个 int 元组，则在元组中指定的所有轴上执行翻转。

返回:

翻转后的框，与 boxes 具有相同的数据类型，不与 boxes 共享内存。

monai.apps.detection.transforms.box_ops.resize_boxes(boxes, src_spatial_size, dst_spatial_size)[source]#

当相应的图像被调整大小时调整框的大小。

参数:

boxes – 源边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
src_spatial_size – 源图像空间大小。
dst_spatial_size – 目标图像空间大小。

返回:

调整大小后的框，与 boxes 具有相同的数据类型，不与 boxes 共享内存。

示例

boxes = torch.ones(1,4)
src_spatial_size = [100, 100]
dst_spatial_size = [128, 256]
resize_boxes(boxes, src_spatial_size, dst_spatial_size) #  will return tensor([[1.28, 2.56, 1.28, 2.56]])

monai.apps.detection.transforms.box_ops.rot90_boxes(boxes, spatial_size, k=1, axes=(0, 1))[source]#

在 axes 指定的平面内将框旋转 90 度。旋转方向从第一个轴指向第二个轴。

参数:

boxes – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
spatial_size – 图像空间大小。
k – 数组旋转 90 度的次数。
axes – (2,) array_like。数组在由 axes 定义的平面内旋转。Axes 必须不同。

返回:

boxes 的旋转视图。

注意

rot90_boxes(boxes, spatial_size, k=1, axes=(1,0)) 是 rot90_boxes(boxes, spatial_size, k=1, axes=(0,1)) 的反向。rot90_boxes(boxes, spatial_size, k=1, axes=(1,0)) 等同于 rot90_boxes(boxes, spatial_size, k=-1, axes=(0,1))。

monai.apps.detection.transforms.box_ops.select_labels(labels, keep)[source]#

对于 labels 中的元素，从中选择索引 keep。

参数:

labels – 数组序列。每个元素代表与 boxes 对应的分类标签或分数，大小为 (N,)。
keep – 要保留的索引，与 labels 中每个元素的长度相同。

返回:

选定的标签，不与原始标签共享内存。

monai.apps.detection.transforms.box_ops.swapaxes_boxes(boxes, axis1, axis2)[source]#

交换框的两个轴。

参数:

boxes (~NdarrayTensor) – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
axis1 (int) – 第一个轴。
axis2 (int) – 第二个轴。

返回类型:

~NdarrayTensor

返回:

交换了两个轴的框。

monai.apps.detection.transforms.box_ops.zoom_boxes(boxes, zoom)[source]#

缩放框。

参数:

boxes – 边界框，Nx4 或 Nx6 torch 张量或 ndarray。框模式假定为 StandardMode。
zoom – 沿空间轴的缩放因子。如果为 float，则所有空间轴的缩放因子相同。如果为序列，则每个空间轴应包含一个值。

返回:

缩放后的框，与 boxes 具有相同的数据类型，不与 boxes 共享内存。

示例

boxes = torch.ones(1,4)
zoom_boxes(boxes, zoom=[0.5,2.2]) #  will return tensor([[0.5, 2.2, 0.5, 2.2]])

用于框操作的一系列“普通”变换 Project-MONAI/MONAI

class monai.apps.detection.transforms.array.AffineBox[source]#: 将仿射矩阵应用于框。

class monai.apps.detection.transforms.array.BoxToMask(bg_label=-1, ellipse_mask=False)[source]#

将框转换为 int16 掩码图像，其大小与输入图像相同。

参数:

bg_label (int) – 输出掩码图像的背景标签，确保它小于任何前景(fg)标签。
ellipse_mask (bool) –
bool。
- 如果为 True，则假定对象形状接近椭圆或椭球体。
- 如果为 False，则假定对象形状接近矩形或立方体，并且很好地占据了边界框。
- 如果用户打算应用随机旋转作为数据增强，我们建议设置 ellipse_mask=True。另请参见 Kalra 等人 “Towards Rotation Invariance in Object Detection”, ICCV 2021。

class monai.apps.detection.transforms.array.ClipBoxToImage(remove_empty=False)[source]#

裁剪边界框和相关的标签/分数，确保它们在图像内。与一组框相关联的标签/分数可能有多个数组。

参数:: remove_empty (bool) – 是否移除实际为空的框和相应的标签。

class monai.apps.detection.transforms.array.ConvertBoxMode(src_mode=None, dst_mode=None)[source]#

此变换将 src_mode 中的框转换为 dst_mode。

参数:

src_mode – 源框模式。如果未给出，此函数将假定为 StandardMode()。
dst_mode – 目标框模式。如果未给出，此函数将假定为 StandardMode()。

Note

StandardMode = CornerCornerModeTypeA，2D 中也表示为“xyxy”，3D 中表示为“xyzxyz”。

src_mode 和 dst_mode 可以是

str: 从 BoxModeName 中选择，例如，
- “xyxy”: 框格式为 [xmin, ymin, xmax, ymax]
- “xyzxyz”: 框格式为 [xmin, ymin, zmin, xmax, ymax, zmax]
- “xxyy”: 框格式为 [xmin, xmax, ymin, ymax]
- “xxyyzz”: 框格式为 [xmin, xmax, ymin, ymax, zmin, zmax]
- “xyxyzz”: 框格式为 [xmin, ymin, xmax, ymax, zmin, zmax]
- “xywh”: 框格式为 [xmin, ymin, xsize, ysize]
- “xyzwhd”: 框格式为 [xmin, ymin, zmin, xsize, ysize, zsize]
- “ccwh”: 框格式为 [xcenter, ycenter, xsize, ysize]
- “cccwhd”: 框格式为 [xcenter, ycenter, zcenter, xsize, ysize, zsize]
BoxMode class: 从 BoxMode 的子类中选择，例如，
- CornerCornerModeTypeA: 等同于“xyxy”或“xyzxyz”
- CornerCornerModeTypeB: 等同于“xxyy”或“xxyyzz”
- CornerCornerModeTypeC: 等同于“xyxy”或“xyxyzz”
- CornerSizeMode: 等同于“xywh”或“xyzwhd”
- CenterSizeMode: 等同于“ccwh”或“cccwhd”
BoxMode object: 从 BoxMode 的子类中选择，例如，
- CornerCornerModeTypeA(): 等同于“xyxy”或“xyzxyz”
- CornerCornerModeTypeB(): 等同于“xxyy”或“xxyyzz”
- CornerCornerModeTypeC(): 等同于“xyxy”或“xyxyzz”
- CornerSizeMode(): 等同于“xywh”或“xyzwhd”
- CenterSizeMode(): 等同于“ccwh”或“cccwhd”
None: 将假定模式为 StandardMode()。

示例

boxes = torch.ones(10,4)
# convert boxes with format [xmin, ymin, xmax, ymax] to [xcenter, ycenter, xsize, ysize].
box_converter = ConvertBoxMode(src_mode="xyxy", dst_mode="ccwh")
box_converter(boxes)

class monai.apps.detection.transforms.array.ConvertBoxToStandardMode(mode=None)[source]#

将给定的框转换为标准模式。标准模式是“xyxy”或“xyzxyz”，表示框格式为 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax]。

参数:: mode – 源框模式。如果未给出，此函数将假定为 StandardMode()。其格式与 ConvertBoxMode 中的 src_mode 相同。

示例

boxes = torch.ones(10,6)
# convert boxes with format [xmin, xmax, ymin, ymax, zmin, zmax] to [xmin, ymin, zmin, xmax, ymax, zmax]
box_converter = ConvertBoxToStandardMode(mode="xxyyzz")
box_converter(boxes)

class monai.apps.detection.transforms.array.FlipBox(spatial_axis=None)[source]#

沿给定的空间轴反转框坐标。保留形状。

参数:: spatial_axis – 要翻转的空间轴。默认为 None。默认的 axis=None 将翻转输入数组的所有轴。如果 axis 为负数，则从最后一个轴开始计数到第一个轴。如果 axis 是一个 int 元组，则在元组中指定的所有轴上执行翻转。

class monai.apps.detection.transforms.array.MaskToBox(bg_label=-1, box_dtype=torch.float32, label_dtype=torch.int64)[source]#

将 int16 掩码图像转换为框，其大小与输入图像相同。与 monai.apps.detection.transforms.array.BoxToMask 配对使用。请确保在使用这两个变换配对时使用相同的 min_fg_label。

参数:

bg_label – 输出掩码图像的背景标签，确保它小于任何前景(fg)标签。
box_dtype – 框的输出 dtype。
label_dtype – 标签的输出 dtype。

class monai.apps.detection.transforms.array.ResizeBox(spatial_size, size_mode='all', **kwargs)[source]#

当相应的图像被调整到给定的空间大小时（通过缩放，而不是裁剪/填充）调整输入框的大小。

参数:

spatial_size – 调整大小操作后空间维度的预期形状。如果 spatial_size 的某些组件是非正值，变换将使用图像大小的相应组件。例如，如果图像的第二个空间维度大小为 64，则 spatial_size=(32, -1) 将被调整为 (32, 64)。
size_mode – 应为“all”或“longest”。如果为“all”，将对所有空间维度使用 spatial_size。如果为“longest”，则重新缩放图像，使最长边等于指定的 spatial_size（在这种情况下必须是 int 类型），同时保持初始图像的纵横比，请参阅：https://albumentations.ai/docs/api_reference/augmentations/geometric/resize/ #albumentations.augmentations.geometric.resize.LongestMaxSize。
kwargs – np.pad 或 torch.pad 函数的其他参数。请注意，np.pad 将通道维度视为第一个维度。

class monai.apps.detection.transforms.array.RotateBox90(k=1, spatial_axes=(0, 1), lazy=False)[source]#

在 axes 指定的平面内将框旋转 90 度。更多详细信息请参见 box_ops.rot90_boxes。

参数:

k (int) – 旋转 90 度的次数。
spatial_axes (tuple[int, int]) – 2 个 int 数字，定义了与 2 个空间轴旋转的平面。默认为 (0, 1)，这是空间维度中的前两个轴。如果轴为负数，则从最后一个轴开始计数到第一个轴。

class monai.apps.detection.transforms.array.SpatialCropBox(roi_center=None, roi_size=None, roi_start=None, roi_end=None, roi_slices=None)[source]#

当相应的图像通过具有相同 ROI 的 SpatialCrop(*) 裁剪时，这是一个通用目的的框裁剪器。区别在于我们不支持 roi_slices 的负索引。

如果预期 ROI 大小的一个维度大于输入图像大小，将不会裁剪该维度。因此，裁剪结果可能小于预期 ROI，并且几张图像的裁剪结果形状可能不完全相同。它可以支持裁剪 ND 空间框。

裁剪区域可以通过多种方式参数化：

每个空间维度的切片列表（不允许使用负索引）
一个空间中心和大小
ROI 的起始和结束坐标

参数:

roi_center – 裁剪 ROI 中心体的体素坐标。
roi_size – 裁剪 ROI 的大小，如果 ROI 大小的一个维度大于图像大小，将不会裁剪图像的该维度。
roi_start – 裁剪 ROI 起始点的体素坐标。
roi_end – 裁剪 ROI 结束点的体素坐标，如果坐标超出图像范围，则使用图像的结束坐标。
roi_slices – 每个空间维度的切片列表。

class monai.apps.detection.transforms.array.StandardizeEmptyBox(spatial_dims)[source]#

当框为空时，此变换将其标准化为形状 (0,4) 或 (0,6)。

参数:: spatial_dims (int) – 边界框的空间维度数量。

class monai.apps.detection.transforms.array.ZoomBox(zoom, keep_size=False, **kwargs)[source]#

使用与 Zoom() 相同的填充或切片设置缩放 ND 框。

参数:

zoom – 沿空间轴的缩放因子。如果为 float，则所有空间轴的缩放因子相同。如果为序列，则每个空间轴应包含一个值。
keep_size – 是否应保留原始大小（必要时填充/切片），默认为 True。
kwargs – np.pad 或 torch.pad 函数的其他参数。请注意，np.pad 将通道维度视为第一个维度。

围绕 monai.apps.detection.transforms.array 中定义的框操作的“普通”变换的字典式包装器集合。

类名以“d”结尾表示基于字典的变换。

monai.apps.detection.transforms.dictionary.AffineBoxToImageCoordinateD[source]#: AffineBoxToImageCoordinated 的别名。

monai.apps.detection.transforms.dictionary.AffineBoxToImageCoordinateDict[source]#: AffineBoxToImageCoordinated 的别名。

class monai.apps.detection.transforms.dictionary.AffineBoxToImageCoordinated(box_keys, box_ref_image_keys, allow_missing_keys=False, image_meta_key=None, image_meta_key_postfix='meta_dict', affine_lps_to_ras=False)[source]#

基于字典的变换，将世界坐标中的框转换为图像坐标。

参数:

box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys – 表示 box_keys 附加到的参考图像的单一键。
remove_empty – 是否移除实际为空的框。
allow_missing_keys – 如果缺少键，不引发异常。
image_meta_key – 显式指示相应元数据字典的键。例如，对于键为 image 的数据，默认元数据在 image_meta_dict 中。元数据是一个字典对象，包含：filename, affine, original_shape 等。它是一个字符串，映射到 box_ref_image_key。如果为 None，将尝试通过 box_ref_image_key_{meta_key_postfix} 构造元数据键。
image_meta_key_postfix – 如果 image_meta_keys=None，则使用 box_ref_image_key_{postfix} 根据键数据获取元数据，默认为 meta_dict，元数据是一个字典对象。例如，要处理键 image，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射矩阵。
affine_lps_to_ras – 默认为 False。但如果 1) 图像是通过 ITKReader 读取的，并且 2) ITKReader 设置了 affine_lps_to_ras=True，并且 3) 框位于世界坐标中，则设置 affine_lps_to_ras=True。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Union[ndarray, Tensor]]

monai.apps.detection.transforms.dictionary.BoxToMaskD[source]#: BoxToMaskd 的别名。

monai.apps.detection.transforms.dictionary.BoxToMaskDict[source]#: BoxToMaskd 的别名。

class monai.apps.detection.transforms.dictionary.BoxToMaskd(box_keys, box_mask_keys, label_keys, box_ref_image_keys, min_fg_label, ellipse_mask=False, allow_missing_keys=False)[source]#

monai.apps.detection.transforms.array.BoxToMask 的基于字典的包装器。与 monai.apps.detection.transforms.dictionary.MaskToBoxd 配对使用。请确保在使用这两个变换配对时使用相同的 min_fg_label。输出 d[box_mask_key] 的背景强度将为 0，因为后续操作可能在边界上填充 0。

这是需要同时应用于图像和框的变换的通用解决方案。通过以下步骤执行：

使用 BoxToMaskd 将框和标签转换为 box_masks；

同时对图像和 box_masks 进行变换，例如旋转或裁剪；

使用 MaskToBoxd 将 box_masks 转换回框和标签。

参数:

box_keys (Union[Collection[Hashable], Hashable]) – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_mask_keys (Union[Collection[Hashable], Hashable]) – 存储变换后输出框掩码结果的键。与 box_keys 长度相同。
label_keys (Union[Collection[Hashable], Hashable]) – 表示与 box_keys 对应的标签的键。与 box_keys 长度相同。
box_ref_image_keys (Union[Collection[Hashable], Hashable]) – 表示 box_keys 和 label_keys 附加到的参考图像的键。
min_fg_label (int) – 最小前景框标签。
ellipse_mask (bool) –
bool。
- 如果为 True，则假定对象形状接近椭圆或椭球体。
- 如果为 False，则假定对象形状接近矩形或立方体，并且很好地占据了边界框。
- 如果用户打算应用随机旋转作为数据增强，我们建议设置 ellipse_mask=True。另请参见 Kalra 等人 “Towards Rotation Invariance in Object Detection”, ICCV 2021。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

示例

# This code snippet creates transforms (random rotation and cropping) on boxes, labels, and image together.
import numpy as np
from monai.transforms import Compose, RandRotated, RandSpatialCropd, DeleteItemsd
transforms = Compose(
    [
        BoxToMaskd(
            box_keys="boxes", label_keys="labels",
            box_mask_keys="box_mask", box_ref_image_keys="image",
            min_fg_label=0, ellipse_mask=True
        ),
        RandRotated(keys=["image","box_mask"],mode=["nearest","nearest"],
            prob=0.2,range_x=np.pi/6,range_y=np.pi/6,range_z=np.pi/6,
            keep_size=True,padding_mode="zeros"
        ),
        RandSpatialCropd(keys=["image","box_mask"],roi_size=128, random_size=False),
        MaskToBoxd(
            box_mask_keys="box_mask", box_keys="boxes",
            label_keys="labels", min_fg_label=0
        )
        DeleteItemsd(keys=["box_mask"]),
    ]
)

monai.apps.detection.transforms.dictionary.ClipBoxToImageD[source]#: ClipBoxToImaged 的别名。

monai.apps.detection.transforms.dictionary.ClipBoxToImageDict[source]#: ClipBoxToImaged 的别名。

class monai.apps.detection.transforms.dictionary.ClipBoxToImaged(box_keys, label_keys, box_ref_image_keys, remove_empty=True, allow_missing_keys=False)[source]#

monai.apps.detection.transforms.array.ClipBoxToImage 的基于字典的包装器。

裁剪边界框和相关的标签/分数，确保它们在图像内。与一个框键相关联的标签/分数可能有多个键。

参数:

box_keys (Union[Collection[Hashable], Hashable]) – 选择框数据进行变换的单一键。框模式假定为 StandardMode。
label_keys (Union[Collection[Hashable], Hashable]) – 表示与 box_keys 对应的标签的键。允许多个键。
box_ref_image_keys (Union[Collection[Hashable], Hashable]) – 表示 box_keys 和 label_keys 附加到的参考图像的单一键。
remove_empty (bool) – 是否移除实际为空的框。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

示例

ClipBoxToImaged(
    box_keys="boxes", box_ref_image_keys="image", label_keys=["labels", "scores"], remove_empty=True
)

monai.apps.detection.transforms.dictionary.ConvertBoxModeD[source]#: ConvertBoxModed 的别名。

monai.apps.detection.transforms.dictionary.ConvertBoxModeDict[source]#: ConvertBoxModed 的别名。

class monai.apps.detection.transforms.dictionary.ConvertBoxModed(box_keys, src_mode=None, dst_mode=None, allow_missing_keys=False)[source]#

monai.apps.detection.transforms.array.ConvertBoxMode 的基于字典的包装器。

此变换将 src_mode 中的框转换为 dst_mode。

示例

data = {"boxes": torch.ones(10,4)}
# convert boxes with format [xmin, ymin, xmax, ymax] to [xcenter, ycenter, xsize, ysize].
box_converter = ConvertBoxModed(box_keys=["boxes"], src_mode="xyxy", dst_mode="ccwh")
box_converter(data)

__init__(box_keys, src_mode=None, dst_mode=None, allow_missing_keys=False)[source]#

参数:

box_keys – 选择数据进行变换的键。
src_mode – 源框模式。如果未给出，此函数将假定为 StandardMode()。其格式与 ConvertBoxMode 中的 src_mode 相同。
dst_mode – 目标框模式。如果未给出，此函数将假定为 StandardMode()。其格式与 ConvertBoxMode 中的 src_mode 相同。
allow_missing_keys – 如果缺少键，不引发异常。

另请参见 monai.apps.detection,transforms.array.ConvertBoxMode

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Union[ndarray, Tensor]]

monai.apps.detection.transforms.dictionary.ConvertBoxToStandardModeD[source]#: ConvertBoxToStandardModed 的别名。

monai.apps.detection.transforms.dictionary.ConvertBoxToStandardModeDict[source]#: ConvertBoxToStandardModed 的别名。

class monai.apps.detection.transforms.dictionary.ConvertBoxToStandardModed(box_keys, mode=None, allow_missing_keys=False)[source]#

monai.apps.detection.transforms.array.ConvertBoxToStandardMode 的基于字典的包装器。

将给定的框转换为标准模式。标准模式是“xyxy”或“xyzxyz”，表示框格式为 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax]。

示例

data = {"boxes": torch.ones(10,6)}
# convert boxes with format [xmin, xmax, ymin, ymax, zmin, zmax] to [xmin, ymin, zmin, xmax, ymax, zmax]
box_converter = ConvertBoxToStandardModed(box_keys=["boxes"], mode="xxyyzz")
box_converter(data)

__init__(box_keys, mode=None, allow_missing_keys=False)[source]#

参数:

box_keys – 选择数据进行变换的键。
mode – 源框模式。如果未给出，此函数将假定为 StandardMode()。其格式与 ConvertBoxMode 中的 src_mode 相同。
allow_missing_keys – 如果缺少键，不引发异常。

另请参见 monai.apps.detection,transforms.array.ConvertBoxToStandardMode

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Union[ndarray, Tensor]]

monai.apps.detection.transforms.dictionary.FlipBoxD[source]#: FlipBoxd 的别名。

monai.apps.detection.transforms.dictionary.FlipBoxDict[source]#: FlipBoxd 的别名。

class monai.apps.detection.transforms.dictionary.FlipBoxd(image_keys, box_keys, box_ref_image_keys, spatial_axis=None, allow_missing_keys=False)[source]#

基于字典的变换，翻转框和图像。

参数:

image_keys – 选择图像数据进行变换的键。
box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys – 表示 box_keys 附加到的参考图像的键。
spatial_axis – 要翻转的空间轴。默认为 None。
allow_missing_keys – 如果缺少键，不引发异常。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

monai.apps.detection.transforms.dictionary.MaskToBoxD[source]#: MaskToBoxd 的别名。

monai.apps.detection.transforms.dictionary.MaskToBoxDict[source]#: MaskToBoxd 的别名。

class monai.apps.detection.transforms.dictionary.MaskToBoxd(box_keys, box_mask_keys, label_keys, min_fg_label, box_dtype=torch.float32, label_dtype=torch.int64, allow_missing_keys=False)[source]#

基于字典的封装器，封装了 monai.apps.detection.transforms.array.MaskToBox。与 monai.apps.detection.transforms.dictionary.BoxToMaskd 配对使用。请确保在使用这两个变换时，使用相同的 min_fg_label。

这是需要同时应用于图像和框的变换的通用解决方案。通过以下步骤执行：

使用 BoxToMaskd 将框和标签转换为 box_masks；

同时对图像和 box_masks 进行变换，例如旋转或裁剪；

使用 MaskToBoxd 将 box_masks 转换回框和标签。

参数:

box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_mask_keys – 存储变换后输出框掩码结果的键。与 box_keys 长度相同。
label_keys – 表示与 box_keys 对应的标签的键。与 box_keys 长度相同。
min_fg_label – 最小前景框标签。
box_dtype – box_keys 的输出数据类型。
label_dtype – label_keys 的输出数据类型。
allow_missing_keys – 如果缺少键，不引发异常。

示例

# This code snippet creates transforms (random rotation and cropping) on boxes, labels, and images together.
import numpy as np
from monai.transforms import Compose, RandRotated, RandSpatialCropd, DeleteItemsd
transforms = Compose(
    [
        BoxToMaskd(
            box_keys="boxes", label_keys="labels",
            box_mask_keys="box_mask", box_ref_image_keys="image",
            min_fg_label=0, ellipse_mask=True
        ),
        RandRotated(keys=["image","box_mask"],mode=["nearest","nearest"],
            prob=0.2,range_x=np.pi/6,range_y=np.pi/6,range_z=np.pi/6,
            keep_size=True,padding_mode="zeros"
        ),
        RandSpatialCropd(keys=["image","box_mask"],roi_size=128, random_size=False),
        MaskToBoxd(
            box_mask_keys="box_mask", box_keys="boxes",
            label_keys="labels", min_fg_label=0
        )
        DeleteItemsd(keys=["box_mask"]),
    ]
)

monai.apps.detection.transforms.dictionary.RandCropBoxByPosNegLabelD[source]#: 是 RandCropBoxByPosNegLabeld 的别名。

monai.apps.detection.transforms.dictionary.RandCropBoxByPosNegLabelDict[source]#: 是 RandCropBoxByPosNegLabeld 的别名。

class monai.apps.detection.transforms.dictionary.RandCropBoxByPosNegLabeld(image_keys, box_keys, label_keys, spatial_size, pos=1.0, neg=1.0, num_samples=1, whole_box=True, thresh_image_key=None, image_threshold=0.0, fg_indices_key=None, bg_indices_key=None, meta_keys=None, meta_key_postfix='meta_dict', allow_smaller=False, allow_missing_keys=False)[source]#

裁剪包含前景框的随机固定大小区域。假设 image_keys 指定的所有预期字段具有相同的形状，并将 patch_index 添加到相应的元数据中。将返回一个字典列表，其中包含所有裁剪后的图像。如果预期空间大小的某个维度大于输入图像大小，则不会裁剪该维度。因此，裁剪结果可能小于预期大小，并且几张图像的裁剪结果可能形状不完全相同。

参数:

image_keys – 用于选择图像数据进行转换的键。它们需要具有相同的空间大小。
box_keys – 用于选择框数据进行转换的单个键。框模式假定为 StandardMode。
label_keys – 表示与 box_keys 对应的标签的键。允许使用多个键。
spatial_size – 裁剪区域的空间大小，例如 [224, 224, 128]。如果 ROI 大小的某个维度大于图像大小，则不会裁剪图像的该维度。如果其组成部分具有非正值，则使用 data[label_key] 对应的尺寸。例如：如果输入数据的空间大小为 [40, 40, 40]，并且 spatial_size=[32, 64, -1]，则输出数据的空间大小将为 [32, 40, 40]。
pos – 与 neg 一起用于计算比率 pos / (pos + neg)，表示选择前景体素作为中心而不是背景体素的概率。
neg – 与 pos 一起用于计算比率 pos / (pos + neg)，表示选择前景体素作为中心而不是背景体素的概率。
num_samples – 每个列表中的样本数（裁剪区域）。
whole_box – 布尔值，默认为 True，是否倾向于在裁剪的前景块中至少包含一个完整的框。即使为 True，如果图像中有多个框，仍可能获得部分框。
thresh_image_key – 如果 thresh_image_key 不为 None，则使用 label == 0 & thresh_image > image_threshold 来选择负样本（背景）中心。因此裁剪中心只会存在于有效的图像区域上。
image_threshold – 如果启用 thresh_image_key，则使用 thresh_image > image_threshold 来确定有效的图像内容区域。
fg_indices_key – 如果提供预计算的 label 的前景索引，将忽略上述 image_key 和 image_threshold，并根据它们随机选择裁剪中心，需要同时提供 fg_indices_key 和 bg_indices_key，期望是展平后的空间索引的 1 维数组。典型用法是先调用 FgBgToIndicesd 变换并缓存结果。
bg_indices_key – 如果提供预计算的 label 的背景索引，将忽略上述 image_key 和 image_threshold，并根据它们随机选择裁剪中心，需要同时提供 fg_indices_key 和 bg_indices_key，期望是展平后的空间索引的 1 维数组。典型用法是先调用 FgBgToIndicesd 变换并缓存结果。
meta_keys – 明确指示相应元数据字典的键。用于将 patch_index 添加到元数据字典中。例如，对于键为 image 的数据，元数据默认为 image_meta_dict。元数据是一个字典对象，包含：filename、original_shape 等。它可以是一个字符串序列，映射到 keys。如果为 None，将尝试通过 key_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 如果 meta_keys 为 None，则使用 key_{postfix} 根据键数据获取元数据，默认为 meta_dict，元数据是一个字典对象。用于将 patch_index 添加到元数据字典中。
allow_smaller – 如果为 False，则如果图像在任何维度上小于请求的 ROI，将引发异常。如果为 True，则任何较小的维度将设置为与裁剪尺寸匹配（即，在该维度上不进行裁剪）。
allow_missing_keys – 如果缺少键，不引发异常。

randomize(boxes, image_size, fg_indices=None, bg_indices=None, thresh_image=None)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

引发:: NotImplementedError – 当子类未重写此方法时。

monai.apps.detection.transforms.dictionary.RandFlipBoxD[source]#: 是 RandFlipBoxd 的别名。

monai.apps.detection.transforms.dictionary.RandFlipBoxDict[source]#: 是 RandFlipBoxd 的别名。

class monai.apps.detection.transforms.dictionary.RandFlipBoxd(image_keys, box_keys, box_ref_image_keys, prob=0.1, spatial_axis=None, allow_missing_keys=False)[source]#

基于字典的变换，以给定的概率随机翻转框和图像。

参数:

image_keys – 选择图像数据进行变换的键。
box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys – 表示 box_keys 附加到的参考图像的键。
prob – 翻转的概率。
spatial_axis – 要翻转的空间轴。默认为 None。
allow_missing_keys – 如果缺少键，不引发异常。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

set_random_state(seed=None, state=None)[source]#

在本地设置随机状态以控制随机性，派生类应使用 self.R 代替 np.random 来引入随机因素。

参数:

seed – 使用整数种子设置随机状态。
state – 使用 np.random.RandomState 对象设置随机状态。

引发:

TypeError – 当 state 不是 Optional[np.random.RandomState] 时。

返回:

一个 Randomizable 实例。

monai.apps.detection.transforms.dictionary.RandRotateBox90D[source]#: 是 RandRotateBox90d 的别名。

monai.apps.detection.transforms.dictionary.RandRotateBox90Dict[source]#: 是 RandRotateBox90d 的别名。

class monai.apps.detection.transforms.dictionary.RandRotateBox90d(image_keys, box_keys, box_ref_image_keys, prob=0.1, max_k=3, spatial_axes=(0, 1), allow_missing_keys=False)[source]#

以概率 prob，输入框和图像在 spatial_axes 指定的平面上旋转 90 度。

参数:

image_keys (Union[Collection[Hashable], Hashable]) – 用于选择图像数据进行转换的键。
box_keys (Union[Collection[Hashable], Hashable]) – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys (Union[Collection[Hashable], Hashable]) – 表示 box_keys 和 label_keys 附加到的参考图像的键。
prob (float) – 旋转的概率。（默认 0.1，有 10% 的概率返回旋转后的数组。）
max_k (int) – 旋转次数将从 np.random.randint(max_k) + 1 中采样。（默认 3）
spatial_axes (tuple[int, int]) – 2 个整数，定义了使用 2 个空间轴进行旋转的平面。默认值：(0, 1)，这是空间维度的前两个轴。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

randomize(data=None)[source]#

在此方法中，应使用 self.R 而不是 np.random 来引入随机因素。

所有 self.R 调用都发生在此处，以便我们更好地识别同步随机状态的错误。

此方法可以根据输入数据的属性生成随机因素。

monai.apps.detection.transforms.dictionary.RandZoomBoxD[source]#: 是 RandZoomBoxd 的别名。

monai.apps.detection.transforms.dictionary.RandZoomBoxDict[source]#: 是 RandZoomBoxd 的别名。

class monai.apps.detection.transforms.dictionary.RandZoomBoxd(image_keys, box_keys, box_ref_image_keys, prob=0.1, min_zoom=0.9, max_zoom=1.1, mode=area, padding_mode=edge, align_corners=None, keep_size=True, allow_missing_keys=False, **kwargs)[source]#

基于字典的变换，以给定的概率在给定的缩放范围内随机缩放输入框和图像。

参数:

image_keys – 选择图像数据进行变换的键。
box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys – 表示 box_keys 附加到的参考图像的键。
prob – 缩放的概率。
min_zoom – 最小缩放因子。可以是浮点数或与图像大小相同的序列。如果是浮点数，从 [min_zoom, max_zoom] 中选择一个随机因子，然后应用于所有空间维度以保持原始空间形状比例。如果是一个序列，min_zoom 应包含每个空间轴的一个值。如果为 3D 数据提供了 2 个值，则使用第一个值保持 H 和 W 维度具有相同的缩放比例。
max_zoom – 最大缩放因子。可以是浮点数或与图像大小相同的序列。如果是浮点数，从 [min_zoom, max_zoom] 中选择一个随机因子，然后应用于所有空间维度以保持原始空间形状比例。如果是一个序列，max_zoom 应包含每个空间轴的一个值。如果为 3D 数据提供了 2 个值，则使用第一个值保持 H 和 W 维度具有相同的缩放比例。
mode – {"nearest", "nearest-exact", "linear", "bilinear", "bicubic", "trilinear", "area"} 插值模式。默认为 "area"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html 它也可以是一个字符串序列，每个元素对应于 keys 中的一个键。
padding_mode – NumPy 数组可用模式：{"constant", "edge", "linear_ramp", "maximum", "mean", "median", "minimum", "reflect", "symmetric", "wrap", "empty"} PyTorch Tensor 可用模式：{"constant", "reflect", "replicate", "circular"}。列出的字符串值之一或用户提供的函数。默认为 "constant"。缩放后填充数据的模式。另请参阅：https://numpy.com.cn/doc/1.18/reference/generated/numpy.pad.html https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html
align_corners – 仅当 mode 为 'linear'、'bilinear'、'bicubic' 或 'trilinear' 时有效。默认值：None。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html 它也可以是布尔值或 None 的序列，每个元素对应于 keys 中的一个键。
keep_size – 是否应保持原始大小（如有需要进行填充），默认为 True。
allow_missing_keys – 如果缺少键，不引发异常。
kwargs – np.pad API 的其他参数，请注意 np.pad 将通道维度视为第一个维度。更多详情：https://numpy.com.cn/doc/1.18/reference/generated/numpy.pad.html

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

set_random_state(seed=None, state=None)[source]#

在本地设置随机状态以控制随机性，派生类应使用 self.R 代替 np.random 来引入随机因素。

参数:

seed – 使用整数种子设置随机状态。
state – 使用 np.random.RandomState 对象设置随机状态。

引发:

TypeError – 当 state 不是 Optional[np.random.RandomState] 时。

返回:

一个 Randomizable 实例。

monai.apps.detection.transforms.dictionary.RotateBox90D[source]#: 是 RotateBox90d 的别名。

monai.apps.detection.transforms.dictionary.RotateBox90Dict[source]#: 是 RotateBox90d 的别名。

class monai.apps.detection.transforms.dictionary.RotateBox90d(image_keys, box_keys, box_ref_image_keys, k=1, spatial_axes=(0, 1), allow_missing_keys=False)[source]#

输入框和图像在 spatial_axes 指定的平面上旋转 90 度，共旋转 k 次。

参数:

image_keys (Union[Collection[Hashable], Hashable]) – 用于选择图像数据进行转换的键。
box_keys (Union[Collection[Hashable], Hashable]) – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys (Union[Collection[Hashable], Hashable]) – 表示 box_keys 和 label_keys 附加到的参考图像的键。
k (int) – 旋转 90 度的次数。
spatial_axes (tuple[int, int]) – 2 个整数，定义了使用 2 个空间轴进行旋转的平面。默认值 (0, 1)，这是空间维度的前两个轴。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

monai.apps.detection.transforms.dictionary.StandardizeEmptyBoxD[source]#: 是 StandardizeEmptyBoxd 的别名。

monai.apps.detection.transforms.dictionary.StandardizeEmptyBoxDict[source]#: 是 StandardizeEmptyBoxd 的别名。

class monai.apps.detection.transforms.dictionary.StandardizeEmptyBoxd(box_keys, box_ref_image_keys, allow_missing_keys=False)[source]#

基于字典的封装器，封装了 monai.apps.detection.transforms.array.StandardizeEmptyBox。

当框为空时，此变换将其标准化为形状 (0,4) 或 (0,6)。

示例

data = {"boxes": torch.ones(0,), "image": torch.ones(1, 128, 128, 128)}
box_converter = StandardizeEmptyBoxd(box_keys=["boxes"], box_ref_image_keys="image")
box_converter(data)

__init__(box_keys, box_ref_image_keys, allow_missing_keys=False)[source]#

参数:

box_keys (Union[Collection[Hashable], Hashable]) – 用于选择数据进行转换的键。
box_ref_image_keys (str) – 表示与 box_keys 关联的参考图像的单个键。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

另请参见 monai.apps.detection,transforms.array.ConvertBoxToStandardMode

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Union[ndarray, Tensor]]

monai.apps.detection.transforms.dictionary.ZoomBoxD[source]#: 是 ZoomBoxd 的别名。

monai.apps.detection.transforms.dictionary.ZoomBoxDict[source]#: 是 ZoomBoxd 的别名。

class monai.apps.detection.transforms.dictionary.ZoomBoxd(image_keys, box_keys, box_ref_image_keys, zoom, mode=area, padding_mode=edge, align_corners=None, keep_size=True, allow_missing_keys=False, **kwargs)[source]#

基于字典的变换，以给定的缩放比例缩放输入框和图像。

参数:

image_keys – 选择图像数据进行变换的键。
box_keys – 选择框数据进行变换的键。框模式假定为 StandardMode。
box_ref_image_keys – 表示 box_keys 附加到的参考图像的键。
zoom – 沿空间轴的缩放因子。如果为 float，则所有空间轴的缩放因子相同。如果为序列，则每个空间轴应包含一个值。
mode – {"nearest", "nearest-exact", "linear", "bilinear", "bicubic", "trilinear", "area"} 插值模式。默认为 "area"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html 它也可以是一个字符串序列，每个元素对应于 keys 中的一个键。
padding_mode – NumPy 数组可用模式：{"constant", "edge", "linear_ramp", "maximum", "mean", "median", "minimum", "reflect", "symmetric", "wrap", "empty"} PyTorch Tensor 可用模式：{"constant", "reflect", "replicate", "circular"}。列出的字符串值之一或用户提供的函数。默认为 "constant"。缩放后填充数据的模式。另请参阅：https://numpy.com.cn/doc/1.18/reference/generated/numpy.pad.html https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html
align_corners – 仅当 mode 为 'linear'、'bilinear'、'bicubic' 或 'trilinear' 时有效。默认值：None。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html 它也可以是布尔值或 None 的序列，每个元素对应于 keys 中的一个键。
keep_size – 是否应保持原始大小（如有需要进行填充），默认为 True。
allow_missing_keys – 如果缺少键，不引发异常。
kwargs – np.pad 或 torch.pad 函数的其他参数。请注意，np.pad 将通道维度视为第一个维度。

inverse(data)[source]#

__call__ 的逆变换。

引发:: NotImplementedError – 当子类未重写此方法时。
返回类型:: dict[Hashable, Tensor]

Anchor#

此脚本改编自 pytorch/vision

class monai.apps.detection.utils.anchor_utils.AnchorGenerator(sizes=((20, 30, 40),), aspect_ratios=(((0.5, 1), (1, 0.5)),), indexing='ij')[source]#

此模块从 torchvision 修改而来，以支持 2D 和 3D 图像。

为一组特征图和图像尺寸生成锚框的模块。

该模块支持为每个特征图计算多种尺寸和纵横比的锚框。

sizes 和 aspect_ratios 应具有相同的元素数量，并且应对应于特征图的数量。

sizes[i] 和 aspect_ratios[i] 可以有任意数量的元素。对于 2D 图像，锚框宽度和高度 w:h = 1:aspect_ratios[i,j]。对于 3D 图像，锚框宽度、高度和深度 w:h:d = 1:aspect_ratios[i,j,0]:aspect_ratios[i,j,1]

AnchorGenerator 将为特征图 i 的每个空间位置输出一组 sizes[i] * aspect_ratios[i] 锚框。

参数:

sizes (Sequence[Sequence[int]]) – 每个锚框的基本大小。len(sizes) 是特征图的数量，即特征金字塔网络 (FPN) 的输出层数。 sizes 的每个元素都是一个 Sequence，表示每个特征图的多个锚框大小。
aspect_ratios (Sequence) – 锚框的纵横比。 len(aspect_ratios) = len(sizes)。对于 2D 图像， aspect_ratios[i] 的每个元素是一个 float 的 Sequence。对于 3D 图像， aspect_ratios[i] 的每个元素是一个 2 值 Sequence 的 Sequence。
indexing (str) –
从 {'ij', 'xy'} 中选择，可选，输出的矩阵 ('ij', 默认且推荐) 或笛卡尔 ('xy') 索引。
- 矩阵 ('ij', 默认且推荐) 索引保持原始轴不变。
- 要使用其他 monai 检测组件，请设置 indexing = 'ij'。
- 笛卡尔 ('xy') 索引交换轴 0 和 1。
- 对于 2D 情况， monai AnchorGenerator(sizes, aspect_ratios, indexing='xy') 和 torchvision.models.detection.anchor_utils.AnchorGenerator(sizes, aspect_ratios) 是等价的。

参考：: pytorch/vision

示例

# 2D example inputs for a 2-level feature maps
sizes = ((10,12,14,16), (20,24,28,32))
base_aspect_ratios = (1., 0.5,  2.)
aspect_ratios = (base_aspect_ratios, base_aspect_ratios)
anchor_generator = AnchorGenerator(sizes, aspect_ratios)

# 3D example inputs for a 2-level feature maps
sizes = ((10,12,14,16), (20,24,28,32))
base_aspect_ratios = ((1., 1.), (1., 0.5), (0.5, 1.), (2., 2.))
aspect_ratios = (base_aspect_ratios, base_aspect_ratios)
anchor_generator = AnchorGenerator(sizes, aspect_ratios)

forward(images, feature_maps)[source]#

为每张图像生成锚框。

参数:

images (Tensor) – 大小为 (B, C, W, H) 或 (B, C, W, H, D)
feature_maps (list[Tensor]) – 对于 FPN 层 i，feature_maps[i] 的大小为 (B, C_i, W_i, H_i) 或 (B, C_i, W_i, H_i, D_i)。此输入参数不必是实际的特征图。任何具有与特征图相同 (C_i, W_i, H_i) 或 (C_i, W_i, H_i, D_i) 大小的列表变量都可以。

返回类型:

list[Tensor]

返回:

一个长度为 B 的列表。每个元素代表此图像的锚框。B 个元素是相同的。

示例

images = torch.zeros((3,1,128,128,128))
feature_maps = [torch.zeros((3,6,64,64,32)), torch.zeros((3,6,32,32,16))]
anchor_generator(images, feature_maps)

generate_anchors(scales, aspect_ratios, dtype=torch.float32, device=None)[source]#

计算当前特征图上多种尺寸和纵横比的单元格锚框形状。

参数:

scales – 一个序列，表示当前特征图的多个锚框大小。
aspect_ratios – 一个序列，表示当前特征图的多个纵横比。对于 2D 图像，它是一个 float 的序列 aspect_ratios[j]，锚框宽度和高度 w:h = 1:aspect_ratios[j]。对于 3D 图像，它是一个 2 值 Sequence 的序列 aspect_ratios[j,0] 和 aspect_ratios[j,1]，锚框宽度、高度和深度 w:h:d = 1:aspect_ratios[j,0]:aspect_ratios[j,1]
dtype – 输出 Tensor 的目标数据类型。
device – 放置输出 Tensor 数据的目标设备。
Returns – 对于 scales 中的每个 s，返回 2D 图像的 [s, s*aspect_ratios[j]]，对于 3D 图像返回 [s, s*aspect_ratios[j,0],s*aspect_ratios[j,1]]。

grid_anchors(grid_sizes, strides)[source]#

(self.cell_anchors, zip(grid_sizes, strides), 0:spatial_dims) 中的每个组合 (a, (g, s), i) 对应于一个特征图。它输出 g[i] 个锚框，它们在方向 i 上相距 s[i] 距离，并且具有与 a 相同的维度。

参数:

grid_sizes (list[list[int]]) – 特征图的空间大小。
strides (list[list[Tensor]]) – 特征图相对于原始图像的步长。

示例

grid_sizes = [[100,100],[50,50]]
strides = [[torch.tensor(2),torch.tensor(2)], [torch.tensor(4),torch.tensor(4)]]

返回类型:: list[Tensor]

num_anchors_per_location()[source]#: 返回每个特征图的锚框形状数量。

set_cell_anchors(dtype, device)[source]#

将 self.cell_anchors 中的每个元素转换为 dtype 并发送到 device。

返回类型:: None

class monai.apps.detection.utils.anchor_utils.AnchorGeneratorWithAnchorShape(feature_map_scales=(1, 2, 4, 8), base_anchor_shapes=((32, 32, 32), (48, 20, 20), (20, 48, 20), (20, 20, 48)), indexing='ij')[source]#

为一组特征图和图像尺寸生成锚框的模块，继承自 AnchorGenerator

该模块支持为每个特征图计算多种基本锚框形状的锚框。

feature_map_scales 应与特征图数量具有相同的元素数量。

base_anchor_shapes 可以有任意数量的元素。对于 2D 图像，每个元素表示锚框宽度和高度 [w,h]。对于 2D 图像，每个元素表示锚框宽度、高度和深度 [w,h,d]。

AnchorGenerator 将为特征图 i 的每个空间位置输出一组 len(base_anchor_shapes) 锚框。

参数:

feature_map_scales – 每个特征图的锚框比例，即特征金字塔网络 (FPN) 的每个输出层。 len(feature_map_scales) 是特征图的数量。 scale[i]*base_anchor_shapes 表示特征图 i 的锚框形状。
base_anchor_shapes – 一个序列，表示一个特征图的多个锚框形状。对于 N-D 图像，它是一个 N 值 Sequence 的 Sequence。
indexing – 从 {‘xy’, ‘ij’} 中选择，可选的笛卡尔 (‘xy’) 或矩阵 (‘ij’, 默认) 输出索引。笛卡尔 (‘xy’) 索引交换轴 0 和 1，这是 torchvision 中的设置。矩阵 (‘ij’, 默认) 索引保持原始轴不变。另请参阅 https://pytorch.ac.cn/docs/stable/generated/torch.meshgrid.html 中的 indexing。

示例

# 2D example inputs for a 2-level feature maps
feature_map_scales = (1, 2)
base_anchor_shapes = ((10, 10), (6, 12), (12, 6))
anchor_generator = AnchorGeneratorWithAnchorShape(feature_map_scales, base_anchor_shapes)

# 3D example inputs for a 2-level feature maps
feature_map_scales = (1, 2)
base_anchor_shapes = ((10, 10, 10), (12, 12, 8), (10, 10, 6), (16, 16, 10))
anchor_generator = AnchorGeneratorWithAnchorShape(feature_map_scales, base_anchor_shapes)

static generate_anchors_using_shape(anchor_shapes, dtype=torch.float32, device=None)[source]#

计算当前特征图上多种尺寸和纵横比的单元格锚框形状。

参数:

anchor_shapes – [w, h] 或 [w, h, d]，大小为 (N, spatial_dims)，表示当前特征图的 N 个锚框形状。
dtype – 输出 Tensor 的目标数据类型。
device – 放置输出 Tensor 数据的目标设备。

返回:

对于 2D 图像，返回 [-w/2, -h/2, w/2, h/2]；对于 3D 图像，返回 [-w/2, -h/2, -d/2, w/2, h/2, d/2]

Matcher#

此脚本中的函数改编自 nnDetection，MIC-DKFZ/nnDetection，后者改编自 torchvision。

与 nndetection 相比的改动如下：1) 注释和 docstring；2) 重新格式化；3) 为 ATSSMatcher 添加调试选项，帮助用户调整参数；4) 在 ATSSMatcher.compute_matches 中添加一个边界情况返回；5) 添加对 float16 cpu 的支持。

class monai.apps.detection.utils.ATSS_matcher.ATSSMatcher(num_candidates=4, similarity_fn=<function box_iou>, center_in_gt=True, debug=False)[source]#

__init__(num_candidates=4, similarity_fn=<function box_iou>, center_in_gt=True, debug=False)[source]#

基于 ATSS 计算匹配 https://arxiv.org/abs/1912.02424 通过自适应训练样本选择弥合基于锚点和无锚点检测之间的差距

参数:

num_candidates (int) – 用于选择候选位置的数量。值越小，匹配器阈值越高，匹配到的候选数越少。
similarity_fn (Callable[Tensor, Tensor, Tensor]) – 用于计算框和锚框之间相似度的函数。
center_in_gt (bool) – 如果为 False（默认），匹配的锚点中心点无需位于地面真值边界框内。对于小对象建议设置为 False。如果为 True，将导致匹配器更严格，匹配到的候选数更少。
debug (bool) – 如果为 True，将打印匹配器阈值以便调整 num_candidates 和 center_in_gt。

compute_matches(boxes, anchors, num_anchors_per_level, num_anchors_per_loc)[source]#

根据 ATTS 计算单个图像的匹配项，改编自 (sfzhang15/ATSS)

参数:

boxes (Tensor) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。框模式假定为 StandardMode
anchors (Tensor) – 要匹配的锚框，Mx4 或 Mx6，也假定为 StandardMode。
num_anchors_per_level (Sequence[int]) – 每个特征金字塔层的锚框数量。
num_anchors_per_loc (int) – 每个位置的锚框数量。

返回类型:

tuple[Tensor, Tensor]

返回:

包含从每个框到每个锚框的相似度的矩阵 [N, M]
包含所有锚框匹配到的框索引的向量（如果使用了背景 BELOW_LOW_THRESHOLD，并且如果应该忽略 BETWEEN_THRESHOLDS，则对应索引）[M]

Note

StandardMode = CornerCornerModeTypeA，对于 2D 也表示为 “xyxy” ([xmin, ymin, xmax, ymax])，对于 3D 表示为 “xyzxyz” ([xmin, ymin, zmin, xmax, ymax, zmax])。

class monai.apps.detection.utils.ATSS_matcher.Matcher(similarity_fn=<function box_iou>)[source]#

Matcher 的基类，用于将框和锚框相互匹配。

参数:: similarity_fn (Callable[Tensor, Tensor, Tensor]) – 用于计算框和锚框之间相似度的函数。

abstract compute_matches(boxes, anchors, num_anchors_per_level, num_anchors_per_loc)[source]#

计算匹配项

参数:

boxes (Tensor) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。框模式假定为 StandardMode
anchors (Tensor) – 要匹配的锚框，Mx4 或 Mx6，也假定为 StandardMode。
num_anchors_per_level (Sequence[int]) – 每个特征金字塔层的锚框数量。
num_anchors_per_loc (int) – 每个位置的锚框数量。

返回类型:

tuple[Tensor, Tensor]

返回:

包含从每个框到每个锚框的相似度的矩阵 [N, M]
包含所有锚框匹配到的框索引的向量（如果使用了背景 BELOW_LOW_THRESHOLD，并且如果应该忽略 BETWEEN_THRESHOLDS，则对应索引）[M]

Box coder#

此脚本从 torchvision 修改而来，以支持 N-D 图像，

pytorch/vision

class monai.apps.detection.utils.box_coder.BoxCoder(weights, boxes_xform_clip=None)[source]#

此类将一组边界框编码和解码为用于训练回归器的表示形式。

参数:

weights – 4 元素 tuple 或 6 元素 tuple
boxes_xform_clip – 高阈值，用于防止将过大值送入 torch.exp()。

示例

box_coder = BoxCoder(weights=[1., 1., 1., 1., 1., 1.])
gt_boxes = torch.tensor([[1,2,1,4,5,6],[1,3,2,7,8,9]])
proposals = gt_boxes + torch.rand(gt_boxes.shape)
rel_gt_boxes = box_coder.encode_single(gt_boxes, proposals)
gt_back = box_coder.decode_single(rel_gt_boxes, proposals)
# We expect gt_back to be equal to gt_boxes

decode(rel_codes, reference_boxes)[source]#

根据一组原始 reference_boxes 和编码的相对框偏移量，

参数:

rel_codes (Tensor) – 编码后的框，Nx4 或 Nx6 的 torch tensor。
reference_boxes (Sequence[Tensor]) – 参考框列表，每个元素是 Mx4 或 Mx6 的 torch tensor。框模式假定为 StandardMode

返回类型:

Tensor

返回:

解码后的框，Nx1x4 或 Nx1x6 的 torch tensor。框模式将为 StandardMode

decode_single(rel_codes, reference_boxes)[source]#

根据一组原始框和编码的相对框偏移量，

参数:

rel_codes (Tensor) – 编码后的框，Nx(4*num_box_reg) 或 Nx(6*num_box_reg) 的 torch tensor。
reference_boxes (Tensor) – 参考框，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode

返回类型:

Tensor

返回:

解码后的框，Nx(4*num_box_reg) 或 Nx(6*num_box_reg) 的 torch tensor。框模式将为 StandardMode

encode(gt_boxes, proposals)[source]#

编码一组 proposals 相对于某些 ground truth (gt) 框。

参数:

gt_boxes (Sequence[Tensor]) – gt 框列表，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode
proposals (Sequence[Tensor]) – 要编码的框列表，每个元素是 Mx4 或 Mx6 的 torch tensor。框模式假定为 StandardMode

返回类型:

tuple[Tensor]

返回:

一个包含编码后的 gt 的 tuple，是用于: 将 proposals 转换为 gt_boxes 的框回归目标，Nx4 或 Nx6 的 torch tensor。

encode_single(gt_boxes, proposals)[source]#

编码 proposals 相对于 ground truth (gt) 框。

参数:

gt_boxes (Tensor) – gt 框，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode
proposals (Tensor) – 要编码的框，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode

返回类型:

Tensor

返回:

编码后的 gt，是用于将 proposals 转换为 gt_boxes 的框回归目标，Nx4 或 Nx6 的 torch tensor。

monai.apps.detection.utils.box_coder.encode_boxes(gt_boxes, proposals, weights)[source]#

编码一组 proposals 相对于某些参考 ground truth (gt) 框。

参数:

gt_boxes (Tensor) – gt 框，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode
proposals (Tensor) – 要编码的框，Nx4 或 Nx6 的 torch tensor。框模式假定为 StandardMode
weights (Tensor) – (cx, cy, w, h) 或 (cx,cy,cz, w,h,d) 的权重。

返回类型:

Tensor

返回:

编码后的 gt，是用于将 proposals 转换为 gt_boxes 的框回归目标，Nx4 或 Nx6 的 torch tensor。

Detection Utilities#

monai.apps.detection.utils.detector_utils.check_input_images(input_images, spatial_dims)[source]#

验证输入的维度（如果无效则引发 ValueError）。

参数:

input_images – 可以是 1) 大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 tensor，或 2) 图像 tensor 列表，每张图像 i 可能具有不同的大小 (C, H_i, W_i) 或 (C, H_i, W_i, D_i)。
spatial_dims – 图像空间维度数量，2 或 3。

monai.apps.detection.utils.detector_utils.check_training_targets(input_images, targets, spatial_dims, target_label_key, target_box_key)[source]#

训练期间验证输入图像/目标（如果无效则引发 ValueError）。

参数:

input_images – 可以是 1) 大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 tensor，或 2) 图像 tensor 列表，每张图像 i 可能具有不同的大小 (C, H_i, W_i) 或 (C, H_i, W_i, D_i)。
targets – dict 列表。每个 dict 有两个键：target_box_key 和 target_label_key，图像中存在的 ground-truth 框。
spatial_dims – 图像空间维度数量，2 或 3。
target_label_key – 目标标签的预期键。
target_box_key – 目标框的预期键。

monai.apps.detection.utils.detector_utils.pad_images(input_images, spatial_dims, size_divisible, mode=constant, **kwargs)[source]#

填充输入图像，使输出空间大小可被 size_divisible 整除。它在末尾进行填充，以创建 (B, C, H, W) 或 (B, C, H, W, D) Tensor。填充后的大小 (H, W) 或 (H, W, D) 可被 size_divisible 整除。默认填充使用常数填充，值为 0.0。

参数:

input_images – 可以是 1) 大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 tensor，或 2) 图像 tensor 列表，每张图像 i 可能具有不同的大小 (C, H_i, W_i) 或 (C, H_i, W_i, D_i)。
spatial_dims – 图像空间维度数量，2D 或 3D。
size_divisible – int 或 Sequence[int]，是输入图像形状的预期模式。如果是 int，则相同的 size_divisible 将应用于所有输入空间维度。
mode – PyTorch Tensor 可用模式：{"constant", "reflect", "replicate", "circular"}。列出的字符串值之一或用户提供的函数。默认为 "constant"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html
kwargs – torch.pad 函数的其他参数。

返回:

图像，一个 (B, C, H, W) 或 (B, C, H, W, D) Tensor
image_sizes，每张图像的原始空间大小。

monai.apps.detection.utils.detector_utils.preprocess_images(input_images, spatial_dims, size_divisible, mode=constant, **kwargs)[source]#

预处理输入图像，包括

验证输入
填充输入，使输出空间尺寸可被 size_divisible 整除。它会在末尾进行填充，以创建一个 (B, C, H, W) 或 (B, C, H, W, D) Tensor。填充后的尺寸 (H, W) 或 (H, W, D) 可被 size_divisible 整除。默认填充使用值为 0.0 的常量填充。

参数:

input_images – 可以是 1) 大小为 (B, C, H, W) 或 (B, C, H, W, D) 的 tensor，或 2) 图像 tensor 列表，每张图像 i 可能具有不同的大小 (C, H_i, W_i) 或 (C, H_i, W_i, D_i)。
spatial_dims – 图像空间维度数量，2 或 3。
size_divisible – int 或 Sequence[int]，是输入图像形状的预期模式。如果是 int，则相同的 size_divisible 将应用于所有输入空间维度。
mode – PyTorch Tensor 可用模式：{"constant", "reflect", "replicate", "circular"}。列出的字符串值之一或用户提供的函数。默认为 "constant"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html
kwargs – torch.pad 函数的其他参数。

返回:

图像，一个 (B, C, H, W) 或 (B, C, H, W, D) Tensor
image_sizes，每张图像的原始空间大小。

monai.apps.detection.utils.predict_utils.check_dict_values_same_length(head_outputs, keys=None)[source]#

我们期望 head_outputs (类型为 Dict[str, List[Tensor]]) 中的值具有相同的长度。如果不是，将引发 ValueError。

参数:

head_outputs – Dict[str, List[Tensor]] 或 Dict[str, Tensor] 类型的数据
keys – head_output 中需要值（List）具有相同长度的键。如果未提供，将使用 head_outputs.keys()。

monai.apps.detection.utils.predict_utils.ensure_dict_value_to_list_(head_outputs, keys=None)[source]#

一个原地（in-place）函数。我们期望 head_outputs 的类型为 Dict[str, List[Tensor]]。但如果它是 Dict[str, Tensor]，此函数会将其转换为 Dict[str, List[Tensor]]。它将被原地修改。

参数:

head_outputs – Dict[str, List[Tensor]] 或 Dict[str, Tensor] 类型的数据，将被原地修改
keys – head_output 中需要值类型为 List[Tensor] 的键。如果未提供，将使用 head_outputs.keys()。

monai.apps.detection.utils.predict_utils.predict_with_inferer(images, network, keys, inferer=None)[source]#

使用 inferer 预测网络字典输出。与直接输出 network(images) 相比，它支持滑动窗口 inferer，可用于处理大型输入。

参数:

images – 网络输入，Tensor 尺寸为 (B, C, H, W) 或 (B, C, H, W, D)
network – 一个接受大小为 (B, C, H, W) 或 (B, C, H, W, D) 的图像 Tensor 作为输入并输出一个字典 Dict[str, List[Tensor]] 或 Dict[str, Tensor] 的网络。
keys – 输出字典中的键，应为网络输出键或其子集。
inferer – 用于处理大型输入的 SlidingWindowInferer。

返回:

来自网络的预测 head_output，类型为 Dict[str, List[Tensor]]

示例

# define a naive network
import torch
import monai
class NaiveNet(torch.nn.Module):
    def __init__(self, ):
        super().__init__()

    def forward(self, images: torch.Tensor):
        return {"cls": torch.randn(images.shape), "box_reg": [torch.randn(images.shape)]}

# create a predictor
network = NaiveNet()
inferer = monai.inferers.SlidingWindowInferer(
    roi_size = (128, 128, 128),
    overlap = 0.25,
    cache_roi_weight_map = True,
)
network_output_keys=["cls", "box_reg"]
images = torch.randn((2, 3, 512, 512, 512))  # a large input
head_outputs = predict_with_inferer(images, network, network_output_keys, inferer)

推理框选择器#

此脚本的一部分改编自 pytorch/vision

class monai.apps.detection.utils.box_selector.BoxSelector(box_overlap_metric=<function box_iou>, apply_sigmoid=True, score_thresh=0.05, topk_candidates_per_level=1000, nms_thresh=0.5, detections_per_img=300)[source]#

用于选择预测框的框选择器。框选择通过以下步骤执行

对于每个级别，丢弃分数低于 self.score_thresh 的边界框。
对于每个级别，保留分数最高的 self.topk_candidates_per_level 个边界框。
对于整个图像，对边界框执行非极大值抑制 (NMS)，重叠阈值为 nms_thresh。
对于整个图像，保留分数最高的 self.detections_per_img 个边界框。

参数:

apply_sigmoid (bool) – 是否应用 sigmoid 从分类 logits 中获取分数
score_thresh (float) – 分数低于 score_thresh 的边界框将被丢弃。
topk_candidates_per_level (int) – 每个级别保留的最大边界框数。
nms_thresh (float) – NMS 的边界框重叠阈值。
detections_per_img (int) – 每张图像保留的最大边界框数。

示例

input_param = {
    "apply_sigmoid": True,
    "score_thresh": 0.1,
    "topk_candidates_per_level": 2,
    "nms_thresh": 0.1,
    "detections_per_img": 5,
}
box_selector = BoxSelector(**input_param)
boxes = [torch.randn([3,6]), torch.randn([7,6])]
logits = [torch.randn([3,3]), torch.randn([7,3])]
spatial_size = (8,8,8)
selected_boxes, selected_scores, selected_labels = box_selector.select_boxes_per_image(
    boxes, logits, spatial_size
)

select_boxes_per_image(boxes_list, logits_list, spatial_size)[source]#

后处理，从分类 logits 和框中生成检测结果。

框选择通过以下步骤执行

对于每个级别，丢弃分数低于 self.score_thresh 的边界框。
对于每个级别，保留分数最高的 self.topk_candidates_per_level 个边界框。
对于整个图像，对边界框执行非极大值抑制 (NMS)，重叠阈值为 nms_thresh。
对于整个图像，保留分数最高的 self.detections_per_img 个边界框。

参数:

boxes_list – 单张图像的预测框列表，每个元素 i 是一个尺寸为 (N_i, 2*spatial_dims) 的 Tensor
logits_list – 单张图像的预测分类 logits 列表，每个元素 i 是一个尺寸为 (N_i, num_classes) 的 Tensor
spatial_size – 图像的空间尺寸

返回:

选定的框，Tensor 尺寸为 (P, 2*spatial_dims)
选定的分数，Tensor 尺寸为 (P, )
选定的标签，Tensor 尺寸为 (P, )

select_top_score_idx_per_level(logits)[source]#

选择分数最高的索引。

索引选择通过以下步骤执行

如果 self.apply_sigmoid 为 True，则通过对 logits 应用 sigmoid 获取分数。否则，将 logits 用作分数。
丢弃分数小于 self.score_thresh 的索引
保留分数最高的前 self.topk_candidates_per_level 个索引

参数:

logits (Tensor) – 预测分类 logits，Tensor 尺寸为 (N, num_classes)

返回:

选定的 M 个索引，Tensor 尺寸为 (M, ) - selected_scores: 选定的 M 个分数，Tensor 尺寸为 (M, ) - selected_labels: 选定的 M 个标签，Tensor 尺寸为 (M, )

返回类型:

topk_idxs

检测指标#

此脚本与 MIC-DKFZ/nnDetection 基本相同。修改包括 1) 代码格式化，2) 文档字符串。

此脚本与 MIC-DKFZ/nnDetection 基本相同。修改包括 1) 代码格式化，2) 文档字符串，3) 允许输入参数 gt_ignore 为可选。（如果为可选，则不会忽略任何 GT 框。）

monai.apps.detection.metrics.matching.matching_batch(iou_fn, iou_thresholds, pred_boxes, pred_classes, pred_scores, gt_boxes, gt_classes, gt_ignore=None, max_detections=100)[source]#

独立地将批量中的框与每个类别的相应地面真实值进行匹配。

参数:

iou_fn – 计算每对的重叠度
iou_thresholds – 定义应评估哪些 IoU 阈值
pred_boxes – 单个批次的预测框；List[[D, dim * 2]]，D 为预测数量
pred_classes – 单个批次的预测类别；List[[D]]，D 为预测数量
pred_scores – 每个边界框的预测分数；List[[D]]，D 为预测数量
gt_boxes – 地面真实框；List[[G, dim * 2]]，G 为地面真实数量
gt_classes – 地面真实类别；List[[G]]，G 为地面真实数量
gt_ignore – 指定哪些地面真实框不计为真阳性。如果未给出，则使用所有 gt_boxes。（与这些框匹配的检测也不计为假阳性）；List[[G]]，G 为地面真实数量
max_detections – 应评估的最大检测数量

返回:

List[Dict[int, Dict[str, np.ndarray]]]，每个 Dict[str, np.ndarray] 对应一张图像。Dict 包含以下键。

dtMatches：匹配的检测 [T, D]，其中 T = 阈值数量，D = 检测数量
gtMatches：匹配的地面真实框 [T, G]，其中 T = 阈值数量，G = 地面真实数量
dtScores：预测分数 [D]，检测分数
gtIgnore：应忽略的地面真实框 [G]，指示是否应忽略地面真实
dtIgnore：应忽略的检测 [T, D]，指示应忽略哪些检测

示例

from monai.data.box_utils import box_iou
from monai.apps.detection.metrics.coco import COCOMetric
from monai.apps.detection.metrics.matching import matching_batch
# 3D example outputs of one image from detector
val_outputs_all = [
        {"boxes": torch.tensor([[1,1,1,3,4,5]],dtype=torch.float16),
        "labels": torch.randint(3,(1,)),
        "scores": torch.randn((1,)).absolute()},
]
val_targets_all = [
        {"boxes": torch.tensor([[1,1,1,2,6,4]],dtype=torch.float16),
        "labels": torch.randint(3,(1,))},
]

coco_metric = COCOMetric(
    classes=['c0','c1','c2'], iou_list=[0.1], max_detection=[10]
)
results_metric = matching_batch(
    iou_fn=box_iou,
    iou_thresholds=coco_metric.iou_thresholds,
    pred_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_outputs_all],
    pred_classes=[val_data_i["labels"].numpy() for val_data_i in val_outputs_all],
    pred_scores=[val_data_i["scores"].numpy() for val_data_i in val_outputs_all],
    gt_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_targets_all],
    gt_classes=[val_data_i["labels"].numpy() for val_data_i in val_targets_all],
)
val_metric_dict = coco_metric(results_metric)
print(val_metric_dict)

重建#

FastMRIReader#

class monai.apps.reconstruction.fastmri_reader.FastMRIReader(*args, **kwargs)[source]#

加载后缀为 “.h5” 的 fastMRI 文件。fastMRI 文件使用 “h5py” 加载时，是类似 HDF5 字典的数据集。其键为

kspace: 包含全采样 kspace
reconstruction_rss: 包含 kspace 的 ifft 的平方和根（root sum of squares）。这
是地面真实图像。

它还有几个属性，键如下

acquisition (str): 数据的采集模式（例如，AXT2 表示 T2 脑部 MRI 扫描）
max (float): 数据的动态范围
norm (float): kspace 的范数
patient_id (str): 记录了测量数据的患者 ID

get_data(dat)[source]#

从已加载的数据中提取数据数组和元数据并返回。此函数返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。

参数:: dat (dict) – 从 h5 文件加载的字典
返回类型:: tuple[ndarray, dict]

read(data)[source]#

从指定的 h5 文件读取数据。请注意，返回的对象是一个字典。

参数:: data – 要读取的文件名。

verify_suffix(filename)[source]#

验证指定的文件格式是否受 h5py 读取器支持。

参数:: filename – 文件名

ConvertToTensorComplex#

monai.apps.reconstruction.complex_utils.convert_to_tensor_complex(data, dtype=None, device=None, wrap_sequence=True, track_meta=False)[source]#

将复数数据转换为双通道 PyTorch tensor。实部和虚部沿最后一个维度堆叠。此函数依赖于 ‘monai.utils.type_conversion.convert_to_tensor’

参数:

data – 输入数据可以是 PyTorch Tensor、numpy 数组、列表、整数和浮点数。将 Tensor、Numpy 数组、浮点数、整数、布尔值转换为 Tensor，字符串和对象保持原样。对于列表，如果适用，将每个项目转换为 Tensor。
dtype – 转换为 Tensor 时的目标数据类型。
device – 放置转换后 Tensor 数据的目标设备。
wrap_sequence – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [tensor(1), tensor(2)]。如果为 True，则 [1, 2] -> tensor([1, 2])。
track_meta – 是否跟踪元信息，如果为 True，将转换为 MetaTensor。默认为 False。

返回:

数据的 PyTorch 版本

示例

import numpy as np
data = np.array([ [1+1j, 1-1j], [2+2j, 2-2j] ])
# the following line prints (2,2)
print(data.shape)
# the following line prints torch.Size([2, 2, 2])
print(convert_to_tensor_complex(data).shape)

ComplexAbs#

monai.apps.reconstruction.complex_utils.complex_abs(x)[source]#

计算复数数组的绝对值。

参数:: x (Union[ndarray, Tensor]) – 输入数组/tensor，最后一个维度有 2 个通道，分别表示实部和虚部。
返回类型:: Union[ndarray, Tensor]
返回:: 沿最后一个维度的绝对值

示例

import numpy as np
x = np.array([3,4])[np.newaxis]
# the following line prints 5
print(complex_abs(x))

RootSumOfSquares#

monai.apps.reconstruction.mri_utils.root_sum_of_squares(x, spatial_dim)[source]#

计算数据的平方和根（root sum of squares，rss）（通常用于多线圈 MRI 样本）

参数:

x (Union[ndarray, Tensor]) – 输入数组/tensor
spatial_dim (int) – 应用 rss 的维度

返回类型:

Union[ndarray, Tensor]

返回:

x 沿 spatial_dim 的 rss

示例

import numpy as np
x = np.ones([2,3])
# the following line prints array([1.41421356, 1.41421356, 1.41421356])
print(rss(x,spatial_dim=0))

ComplexMul#

monai.apps.reconstruction.complex_utils.complex_mul(x, y)[source]#

计算复数乘法。支持最后一个维度等于 2（实部/虚部通道）的 N 维输入

参数:

x (Union[ndarray, Tensor]) – 输入数组/tensor，最后一个维度有 2 个通道，分别表示实部和虚部。
y (Union[ndarray, Tensor]) – 输入数组/tensor，最后一个维度有 2 个通道，分别表示实部和虚部。

返回类型:

Union[ndarray, Tensor]

返回:

x 和 y 的复数乘法

示例

import numpy as np
x = np.array([[1,2],[3,4]])
y = np.array([[1,1],[1,1]])
# the following line prints array([[-1,  3], [-1,  7]])
print(complex_mul(x,y))

ComplexConj#

monai.apps.reconstruction.complex_utils.complex_conj(x)[source]#

计算数组/tensor 的复共轭。支持最后一个维度等于 2（实部/虚部通道）的 N 维输入

参数:: x (Union[ndarray, Tensor]) – 输入数组/tensor，最后一个维度有 2 个通道，分别表示实部和虚部。
返回类型:: Union[ndarray, Tensor]
返回:: x 的复共轭

示例

import numpy as np
x = np.array([[1,2],[3,4]])
# the following line prints array([[ 1, -2], [ 3, -4]])
print(complex_conj(x))

Vista3d#

monai.apps.vista3d.inferer.point_based_window_inferer(inputs, roi_size, predictor, point_coords, point_labels, class_vector=None, prompt_class=None, prev_mask=None, point_start=0, center_only=True, margin=5, **kwargs)[source]#

基于点的窗口 inferer，它接受输入图像、一组点和一个模型，并返回分割后的图像。此 inferer 算法将输入图像裁剪成以点集为中心的 patches，然后进行 patch 推理和平均输出拼接，最后返回分割掩码。

参数:

inputs – [1CHWD]，待处理的输入图像。
roi_size – 用于推理的空间窗口大小。当其分量为 None 或非正数时，将使用相应的输入维度。如果 roi_size 的分量为非正值，则 transform 将使用图像尺寸的相应分量。例如，如果图像的第二个空间维度大小为 64，roi_size=(32, -1) 将被调整为 (32, 64)。
sw_batch_size – 运行窗口切片的批大小。
predictor – 模型。对于 vista3D，输出为 [B, 1, H, W, D]，需要转置为 [1, B, H, W, D]。在 kwargs 中为 vista3d 添加 transpose=True。
point_coords – [B, N, 3]。B 个前景对象的点坐标，每个对象有 N 个点。
point_labels – [B, N]。点标签。0/1 表示常规支持或零样本类别的负点/正点。2/3 表示特殊支持类别（例如肿瘤、血管）的负点/正点。
class_vector – [B]。用于类别头自动分割。可以为 None 值。
prompt_class – [B]。与 class_vector 相同，表示点类别，并通知点头关于支持类别或零样本，不用于自动分割。如果为 None，则点头默认为支持类别分割。
prev_mask – [1, B, H, W, D]。值在 sigmoid 之前。之前分割掩码的可选 tensor。
point_start – 仅使用从该数字开始的点。此数字之前的所有点用于生成 prev_mask。如果在给定 prev_mask 的情况下，这用于避免重新计算先前迭代中的点。
center_only – 对于每个点，仅裁剪以该点为中心的 patch。如果为 false，则对每个点裁剪 3 个 patches。
margin – 如果 center_only 为 false，则此值为点到 patch 边界的距离。

返回:

[1, B, H, W, D]。值在 sigmoid 之前。

返回类型:

拼接输出 (stitched_output)

注意：此函数仅支持 B=1 的单个对象推理（SINGLE OBJECT INFERENCE）。

class monai.apps.vista3d.transforms.VistaPreTransformd(keys, allow_missing_keys=False, special_index=(25, 26, 27, 28, 29, 117), labels_dict=None, subclass=None)[source]#

__init__(keys, allow_missing_keys=False, special_index=(25, 26, 27, 28, 29, 117), labels_dict=None, subclass=None)[source]#

Vista3d 的预转换。

它执行两个功能

如果标签提示显示点属于特殊类别（由特殊索引定义，例如肿瘤、血管），将点标签从 0（负）、1（正）转换为特殊值 2（负）、3（正）。
如果标签提示位于 subclass 中的键内，将标签提示转换为由 subclass[key] 定义的其子类。例如，“lung” 标签转换为 [“left lung”, “right lung”]。

label_prompt 是一个长度为 [B] 的整数值列表，而 point_labels 是一个长度为 B 的列表，其中每个元素是长度为 [B, N] 的整数值。

参数:

keys – 需要进行变换的相应项的键。
special_index – 定义特殊类别的索引。
subclass – 一个将标签提示映射到其子类的字典。
allow_missing_keys – 如果缺少键，不引发异常。

class monai.apps.vista3d.transforms.VistaPostTransformd(keys, allow_missing_keys=False)[source]#

__init__(keys, allow_missing_keys=False)[source]#

Vista3d 的后转换。它将模型的输出 logits 转换为最终分割掩码。如果 label_prompt 为 None，则输出将进行阈值处理以生成顺序索引 [0,1,2,…]，否则索引将为 [0, label_prompt[0], label_prompt[1], …]。如果在 label_prompt 为 None 同时提供了 points，则模型将执行后处理以移除不包含正点的区域。

参数:

keys (Union[Collection[Hashable], Hashable]) – 需要进行变换的相应项的键。
dataset_transforms – 指定相应数据集转换的字典：key：数据集名称，value：数据转换列表。
dataset_key – 从数据字典中获取数据集名称的键，默认为 “dataset_name”。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

class monai.apps.vista3d.transforms.Relabeld(keys, label_mappings, dtype=<class 'numpy.int16'>, dataset_key='dataset_name', allow_missing_keys=False)[source]#

__init__(keys, label_mappings, dtype=<class 'numpy.int16'>, dataset_key='dataset_name', allow_missing_keys=False)[source]#

根据指定的映射重新映射输入数据字典中的体素标签。

这个本地 -> 全局标签映射列表将应用于每个输入 data[keys]。如果 data[dataset_key] 不在 label_mappings 中，则将使用 label_mappings[‘default’]`。如果 label_mappings[data[dataset_key]] 为 None，则不会执行任何重新标记。

参数:

keys (Union[Collection[Hashable], Hashable]) – 需要进行变换的相应项的键。
label_mappings (dict[str, list[tuple[int, int]]]) – 指定如何将本地数据集类索引映射到全局类索引的字典。字典键是数据集名称，值是 (本地标签, 全局标签) 对的列表。这个本地 -> 全局标签映射列表将应用于每个输入 data[keys]。如果 data[dataset_key] 不在 label_mappings 中，则将使用 label_mappings[‘default’]`。如果 label_mappings[data[dataset_key]] 为 None，则不会执行任何重新标记。请将 label_mappings={} 设置为空，以完全跳过此转换。
dtype (Union[dtype, type, str, None]) – 将输出数据转换为指定 dtype，默认为 float32。
dataset_key (str) – 从数据字典中获取数据集名称的键，默认为 “dataset_name”。
allow_missing_keys (bool) – 如果键丢失，则不引发异常。

monai.apps.vista3d.sampler.sample_prompt_pairs(labels, label_set, max_prompt=None, max_foreprompt=None, max_backprompt=1, max_point=20, include_background=False, drop_label_prob=0.2, drop_point_prob=0.2, point_sampler=None, **point_sampler_kwargs)[source]#

为 VISTA3D 训练采样训练对。

参数:

labels – [1, 1, H, W, D]，地面真实标签。
label_set – 特定数据集的标签列表。注意，如果 label_set 中包含 0，它将被添加到自动分支训练中。对于多部分标记数据集训练，建议从 label_set 中移除 0；对于特定数据集的微调，建议添加 0。原因是，在一个部分标记的数据集中标记为 0 的区域可能在另一个数据集中包含前景。
max_prompt – int，最大总提示数量，包括前景和背景。
max_foreprompt – int，来自前景的最大提示数量。
max_backprompt – int，来自背景的最大提示数量。
max_point – 每个对象的最大点数量。
include_background – 是否将 0 包含到训练提示中。如果包含，背景 0 将被视为与前景相同，并会采样点。仅当用户希望通过点击点分割背景 0 时才能设置为 true，否则应始终为 false。
drop_label_prob – 丢弃标签提示的概率。
drop_point_prob – 丢弃点提示的概率。
point_sampler – 用于使用超体素增强掩码的采样器。
point_sampler_kwargs – point_sampler 的参数。

返回:

label_prompt (Tensor | None): 形状为 [B, 1] 的 Tensor，包含用于训练自动分割的类别。
point (Tensor | None): 形状为 [B, N, 3] 的 Tensor，表示每个类别的相应点。注意，背景标签提示也需要匹配点（例如使用 [0, 0, 0]）。
point_label (Tensor | None): 形状为 [B, N] 的 Tensor，表示每个点的相应点标签（负或正）。-1 用于填充背景标签提示，将被忽略。
prompt_class (Tensor | None): 形状为 [B, 1] 的 Tensor，与 label_prompt 完全相同，用于训练期间的标签索引。如果 label_prompt 为 None，则使用 prompt_class 来识别点类别。

返回类型:

tuple

Auto3DSeg#

class monai.apps.auto3dseg.AlgoEnsemble[source]#

集成方法的基础类

__call__(pred_param=None)[source]#

使用集成的模型预测结果。

参数:

pred_param –

预测参数字典。键分为两组：第一组在此函数中使用，第二组将传递给 InferClass 以覆盖类函数的参数。第一组包含

"infer_files"：要读取的图像文件路径列表。

"files_slices"：类型为 slice 的值。files_slices 将对 "infer_files" 进行切片，仅对 infer_files[file_slices] 进行预测。

"mode"：集成模式。目前支持 “mean” 和 “vote”（多数投票）方案。

"image_save_func"：用于实例化 SaveImage 转换的字典。指定后，集成预测将保存预测文件，而不是将文件保留在内存中。示例：{“_target_”: “SaveImage”, “output_dir”: “./”}

"sigmoid"：使用 sigmoid 函数（例如 x > 0.5）将预测概率图转换为标签类别预测，否则使用 argmax(x)。

"algo_spec_params"：一个字典，用于添加特定于模型的 pred_params。字典格式为 {“<算法名称>”: “<该算法的 pred_params>”}。

第二组参数在每个 Algo 模板的 config 中定义。请查看：Project-MONAI/research-contributions

返回:

一个 tensor 列表或文件路径列表，取决于是否设置了 "image_save_func"。

ensemble_pred(preds, sigmoid=False)[source]#

使用 “mean” 或 “vote” 方法集成结果

参数:

preds – Tensor-Like 格式的概率预测列表。
sigmoid – 使用 sigmoid 函数对概率 one-hot map 进行阈值处理，否则使用 argmax。默认为 False

返回:

一个 tensor，它是集成的预测结果。

get_algo(identifier)[source]#

按标识符获取模型。

参数:: identifier – bundleAlgo 的名称

get_algo_ensemble()[source]#

获取排序后的算法集成，如果未开始排序，则获取空列表。

返回:: Algo 列表

set_algos(infer_algos)[source]#: 在集成中注册模型

set_infer_files(dataroot, data_list_or_path, data_key='testing')[source]#

设置用于执行模型推理的文件。

参数:

dataroot – 文件路径
data_list_or_path – 数据源文件路径

class monai.apps.auto3dseg.AlgoEnsembleBestByFold(n_fold=5)[source]#

集成方法，选择在每个折叠中表现最佳的模型。

参数:: n_fold (int) – 训练中使用的交叉验证折叠数

collect_algos()[source]#

通过找到每个交叉验证折叠中的最佳模型来对算法进行排名

返回类型:: None

class monai.apps.auto3dseg.AlgoEnsembleBestN(n_best=5)[source]#

集成方法，使用模型的 best_metric 分数从所有模型中选择 N 个模型

参数:: n_best (int) – 为集成选择的模型数量 (N)。

collect_algos(n_best=-1)[source]#

通过找到排名前 N 个 (n_best) 的验证分数来对算法进行排名。

返回类型:: None

sort_score()[source]#: 对 best_metrics 进行排序

class monai.apps.auto3dseg.AlgoEnsembleBuilder(history, data_src_cfg_name=None)[source]#

从配置和参数构建集成工作流程。

参数:

history – 训练过的 bundleAlgo 算法的集合。
data_src_cfg_name – 数据源文件名。

示例

builder = AlgoEnsembleBuilder(history, data_src_cfg)
builder.set_ensemble_method(BundleAlgoEnsembleBestN(3))
ensemble = builder.get_ensemble()

add_inferer(identifier, gen_algo, best_metric=None)[source]#

将模型 inferer 添加到构建器。

参数:

identifier – bundleAlgo 的名称。
gen_algo – 训练过的 BundleAlgo 模型对象。
best_metric – 训练模型的验证集上的最佳指标。

get_ensemble()[source]#: 获取集成

set_ensemble_method(ensemble, *args, **kwargs)[source]#

设置集成方法。

参数:: ensemble (AlgoEnsemble) – 要构建的 AlgoEnsemble。
返回类型:: None

class monai.apps.auto3dseg.AutoRunner(work_dir='./work_dir', input=None, algos=None, analyze=None, algo_gen=None, train=None, hpo=False, hpo_backend='nni', ensemble=True, not_use_cache=False, templates_path_or_url=None, allow_skip=True, mlflow_tracking_uri=None, mlflow_experiment_name=None, **kwargs)[source]#

一个接口，用于以最小的输入和对 Auto3Dseg 内部状态的理解来处理 Auto3Dseg。用户可以在一行代码中使用默认设置运行 Auto3Dseg。他们也可以在额外几行代码中自定义 Auto3DSeg 的高级功能。自定义示例包括

更改交叉验证折叠数

更改训练/预测参数

更改集成方法

自动超参数优化。

接口的输出是一个目录，其中包含

数据统计分析报告

算法定义文件（脚本、配置、pickle 对象）和训练结果（检查点、准确率）

最终算法集成在测试数据集上的预测结果

YAML 格式的输入参数副本

缓存的中间结果

参数:

work_dir – 工作目录，用于保存中间和最终结果。
input – 配置字典或 YAML 格式的配置文件路径。配置应包含 datalist、dataroot、modality、multigpu 和 class_names 信息。
algos – 可选地指定要使用的算法。如果是一个字典，格式必须为 {“algname”: dict(_target_=”algname.scripts.algo.AlgnameAlgo”, template_path=”algname”), …}。如果是一个列表或字符串，则定义要使用的算法名称的子集，例如从 templates_path_or_url 提供的完整算法模板集中选择 ‘segresnet’ 或 [‘segresnet’, ‘dints’]。默认为 None，表示使用所有可用算法。
analyze – 运行 DataAnalyzer 并生成数据统计报告的开关。默认为 None，表示根据缓存自动决定，仅在尚未完成此步骤时运行数据分析。
algo_gen – 运行 AlgoGen 并生成模板化 BundleAlgos 的开关。默认为 None，表示根据缓存自动决定，仅在尚未完成此步骤时运行算法文件夹生成。
train – 运行训练并生成算法检查点的开关。默认为 None，表示根据缓存自动决定，仅在尚未完成此步骤时运行训练。
hpo – 在训练阶段使用超参数优化（HPO）。用户可以提供超参数列表，将执行搜索以考察算法性能。
hpo_backend – 指示 HPO 后端的字符串。目前仅支持 NNI 网格搜索模式。
ensemble – 运行模型集成并使用集成在测试数据集上预测输出的开关。
not_use_cache – 如果值为 True，将忽略数据分析、算法生成或训练中的所有缓存结果，并从头开始运行管道。
templates_path_or_url – 包含算法模板的文件夹或 url。如果未提供 None，将下载默认模板 zip url 并将其提取到 work_dir 中。
allow_skip – 传递给 BundleGen 进程的开关，用于根据 Auto3DSeg DataAnalyzer 对数据集的分析来确定是否可以跳过默认模板中的某些 Algo。
mlflow_tracking_uri – MLflow 服务器的跟踪 URI，可以是本地目录或远程跟踪服务器的地址；如果值为 None，MLflow 运行将记录在算法的模型文件夹中。
mlflow_experiment_name – MLflow 服务器中实验的名称。
kwargs – 集成推理的图像写入参数。kwargs 格式遵循 SaveImage 转换。更多信息，请查看 https://docs.monai.org.cn/en/stable/transforms.html#saveimage。

示例

用户可以使用一行代码启动 Auto3Dseg 工作流程

python -m monai.apps.auto3dseg AutoRunner run --input             '{"modality": "ct", "datalist": "dl.json", "dataroot": "/dr", "multigpu": true, "class_names": ["A", "B"]}'

用户还可以将输入字典保存为输入 YAML 文件，并使用下面的一行代码

python -m monai.apps.auto3dseg AutoRunner run --input=./input.yaml

用户可以指定 work_dir 和数据源配置输入，然后运行 AutoRunner

work_dir = "./work_dir"
input = "path/to/input_yaml"
runner = AutoRunner(work_dir=work_dir, input=input)
runner.run()

用户可以指定要使用的算法子集，然后运行 AutoRunner

work_dir = "./work_dir"
input = "path/to/input_yaml"
algos = ["segresnet", "dints"]
runner = AutoRunner(work_dir=work_dir, input=input, algos=algos)
runner.run()

用户可以指定一个包含算法模板的本地文件夹，然后运行 AutoRunner

work_dir = "./work_dir"
input = "path/to/input_yaml"
algos = "segresnet"
templates_path_or_url = "./local_path_to/algorithm_templates"
runner = AutoRunner(work_dir=work_dir, input=input, algos=algos, templates_path_or_url=templates_path_or_url)
runner.run()

用户可以通过以下方式指定训练参数

input = "path/to/input_yaml"
runner = AutoRunner(input=input)
train_param = {
    "num_epochs_per_validation": 1,
    "num_images_per_batch": 2,
    "num_epochs": 2,
}
runner.set_training_params(params=train_param)  # 2 epochs
runner.run()

用户可以指定交叉验证的折叠数量

input = "path/to/input_yaml"
runner = AutoRunner(input=input)
runner.set_num_fold(n_fold = 2)
runner.run()

用户可以在算法集成推理期间指定预测参数

input = "path/to/input_yaml"
pred_params = {
    'files_slices': slice(0,2),
    'mode': "vote",
    'sigmoid': True,
}
runner = AutoRunner(input=input)
runner.set_prediction_params(params=pred_params)
runner.run()

用户可以定义网格搜索空间，并在训练期间使用 HPO。

input = "path/to/input_yaml"
runner = AutoRunner(input=input, hpo=True)
runner.set_nni_search_space({"learning_rate": {"_type": "choice", "_value": [0.0001, 0.001, 0.01, 0.1]}})
runner.run()

注意

work_dir 中的预期结果如下

work_dir/
├── algorithm_templates # bundle algo templates (scripts/configs)
├── cache.yaml          # Autorunner will automatically cache results to save time
├── datastats.yaml      # datastats of the dataset
├── dints_0             # network scripts/configs/checkpoints and pickle object of the algo
├── ensemble_output     # the prediction of testing datasets from the ensemble of the algos
├── input.yaml          # copy of the input data source configs
├── segresnet_0         # network scripts/configs/checkpoints and pickle object of the algo
├── segresnet2d_0       # network scripts/configs/checkpoints and pickle object of the algo
└── swinunetr_0         # network scripts/configs/checkpoints and pickle object of the algo

export_cache(**kwargs)[source]#: 将缓存状态保存为工作目录中的 cache.yaml 文件

inspect_datalist_folds(datalist_filename)[source]#

返回 datalist 文件中的折叠数量，如果未提供，则分配折叠编号。

参数:: datalist_filename (str) – datalist 文件路径。

注意

如果未提供 fold 键，它会在训练键列表中自动生成 5 个折叠分配。如果 validation 键列表可用，则假定为单折叠验证。

返回类型:: int

read_cache()[source]#

检查当前工作目录中每一步的中间结果是否已缓存

返回:: 缓存结果的字典。如果 not_use_cache 设置为 True，或者工作目录中没有缓存文件，结果将是 empty_cache，其中所有 has_cache 键都设置为 False。

run()[source]#: 运行 AutoRunner 管道

set_analyze_params(params=None)[source]#

设置数据分析的额外参数。

参数:: params – 一个字典，定义训练期间的覆盖键值对。覆盖方法由算法类定义。

set_device_info(cuda_visible_devices=None, num_nodes=None, mn_start_method=None, cmd_prefix=None)[source]#

设置设备相关信息

参数:

cuda_visible_devices – 为数据分析器、训练和集成定义 GPU ID。GPU ID 列表 [0,1,2,3] 或字符串 “0,1,2,3”。默认使用环境变量 “CUDA_VISIBLE_DEVICES” 或所有可用设备。
num_nodes – 训练和集成的节点数量。默认使用环境变量 “NUM_NODES”，如果 “NUM_NODES” 未设置则为 1。
mn_start_method – 多节点启动方法。Autorunner 将使用此方法启动多节点进程。默认使用环境变量 “MN_START_METHOD”，如果 “MN_START_METHOD” 未设置则为 ‘bcprun’。
cmd_prefix –
在 BundleAlgo 和 EnsembleRunner 中运行子进程的命令行前缀。默认使用环境变量 “CMD_PREFIX” 或 None，示例包括
- 单个 GPU/CPU 或多节点 bcprun：“python “ 或 “/opt/conda/bin/python3.9 “，
- 单节点多 GPU 运行 “torchrun –nnodes=1 –nproc_per_node=2 “
如果用户定义此前缀，请确保 –nproc_per_node 与 cuda_visible_device 或 os.env[‘CUDA_VISIBLE_DEVICES’] 匹配。此外，始终设置 –nnodes=1。对于多节点，设置 num_nodes。

set_ensemble_method(ensemble_method_name='AlgoEnsembleBestByFold', **kwargs)[source]#

设置捆绑包集成方法的名称以及保存图像转换参数的参数。

参数:

ensemble_method_name (str) – 集成方法的名称。仅支持两种方法：“AlgoEnsembleBestN” 和 “AlgoEnsembleBestByFold”。
kwargs (Any) – 用于定义集成方法的关键字参数。目前仅支持用于 AlgoEnsembleBestN 的 n_best。

返回类型:

AutoRunner

set_gpu_customization(gpu_customization=False, gpu_customization_specs=None)[source]#

设置基于 GPU 的参数自定义/优化选项。

参数:

gpu_customization – 用于根据 GPU 自动确定是否为每个 bundleAlgo 自定义/优化捆绑包脚本/配置参数的开关。自定义参数通过模拟实际模型训练过程和超参数优化（HPO）实验的模拟训练获得。

gpu_customization_specs (可选) –

用于允许用户覆盖 HPO 设置的字典。用户可以按如下方式覆盖部分变量或全部变量。结构如下。

gpu_customization_specs = {
    'ALGO': {
        'num_trials': 6,
        'range_num_images_per_batch': [1, 20],
        'range_num_sw_batch_size': [1, 20]
    }
}

ALGO –
算法名称。可以是某个算法名称（例如 ‘dints’），也可以是 ‘universal’，后者将更改应用于所有算法。可能的选项包括
- {"universal", "dints", "segresnet", "segresnet2d", "swinunetr"}。
num_trials – 要运行的 HPO 试验/实验次数。
range_num_images_per_batch – 每个 mini-batch 的图像数量范围。
range_num_sw_batch_size – 滑动窗口 inferer 中的批量大小范围。

set_hpo_params(params=None)[source]#

设置 HPO 模块和训练前算法的参数。它将尝试 (1) 使用 params 中的键值对覆盖捆绑包模板 (2) 如果找到键是以下之一，则更改 HPO 模块（例如 NNI）的配置

“trialCodeDirectory”

“trialGpuNumber”

“trialConcurrency”

“maxTrialNumber”

“maxExperimentDuration”

“tuner”

“trainingService”

以及 (3) 如果用户只想生成 NNI 配置而不启动 NNI 服务，则启用干运行模式。

参数:: params – 一个字典，定义算法实例化期间的覆盖键值对。对于 BundleAlgo，它将覆盖模板配置填充。

注意

用户可以在 params 中将 nni_dry_run 设置为 True，以启用 NNI 后端的空运行模式。

set_image_save_transform(**kwargs)[source]#

设置集成输出变换。

参数:: kwargs (Any) – 集成推理的图像写入参数。kwargs 格式遵循 SaveImage 变换。有关更多信息，请查看 https://docs.monai.org.cn/en/stable/transforms.html#saveimage。
返回类型:: AutoRunner

set_nni_search_space(search_space)[source]#

设置 NNI 参数搜索的搜索空间。

参数:: search_space (dict[str, Any]) – 字典形式的超参数搜索空间。有关更多信息，请查阅 NNI 文档：https://nni.readthedocs.io/en/v2.2/Tutorial/SearchSpaceSpec.html 。
返回类型:: AutoRunner

set_num_fold(num_fold=5)[source]#

设置所有算法的交叉验证折数。

参数:: num_fold (int) – 定义折数的正整数。
返回类型:: AutoRunner

set_prediction_params(params=None)[source]#

设置所有算法的预测参数。

参数:: params – 一个字典，定义预测期间覆盖的键值对。覆盖方法由算法类定义。

示例

对于 BundleAlgo 对象，这组参数将指定算法集成仅推理前: 测试数据集列表中的两个文件 {“file_slices”: slice(0, 2)}

set_training_params(params=None)[source]#

设置所有算法的训练参数。

参数:: params – 一个字典，定义训练期间的覆盖键值对。覆盖方法由算法类定义。

示例

对于 BundleAlgo 对象，将训练时间缩短到几个 epoch 的训练参数可以是: {“num_epochs”: 2, “num_epochs_per_validation”: 1}

class monai.apps.auto3dseg.BundleAlgo(template_path)[source]#

一种由一组捆绑配置和脚本表示的算法。

BundleAlgo.cfg 是一个 monai.bundle.ConfigParser 实例。

from monai.apps.auto3dseg import BundleAlgo

data_stats_yaml = "../datastats.yaml"
algo = BundleAlgo(template_path="../algorithm_templates")
algo.set_data_stats(data_stats_yaml)
# algo.set_data_src("../data_src.json")
algo.export_to_disk(".", algo_name="segresnet2d_1")

此类从“捆绑模板”目录创建 MONAI 捆绑包。与常规 MONAI 捆绑包格式不同，捆绑包模板可能包含占位符，必须在使用 fill_template_config 方法并在 export_to_disk 期间填充这些占位符。然后创建的捆绑包保留与模板相同的文件结构。

__init__(template_path)[source]#

基于预定义的算法模板创建算法实例。

参数:: template_path (Union[str, PathLike]) – 包含算法模板文件夹的路径。请查看 Project-MONAI/research-contributions

export_to_disk(output_path, algo_name, **kwargs)[source]#

填充配置模板，将捆绑包（配置 + 脚本）写入文件夹 output_path/algo_name。

参数:

output_path (str) – 导出“scripts”和“configs”目录的路径。
algo_name (str) – 算法的标识符（通常包含名称和额外信息，如折叠 ID）。
kwargs (Any) – 其他参数，包括：“copy_dirs=True/False” 表示是否将模板复制为输出而不是原地操作，“fill_template=True/False” 表示是否填充模板中的占位符。其他参数用于 fill_template_config 函数。

返回类型:

None

fill_template_config(data_stats_filename, algo_path, **kwargs)[source]#

构建此算法实例时定义的配置文件可能没有完整的训练和验证流水线。流水线的一些配置组件和超参数取决于训练数据和其他因素。提供此 API 旨在允许创建功能齐全的配置文件。返回填充模板配置的记录：{“<配置名称>”: {“<占位符键>”: 值, …}, …}。

参数:: data_stats_filename (str) – 数据统计报告的文件名（由 DataAnalyzer 生成）

注意

模板填充是可选的。用户可以使用数据分析结果构建一组预填充的配置，而无需替换值。如果用户想要自己的自动配置模板填充方式，也打算在 BundleAlgo 的子类中重新实现它。返回

返回类型:: dict (字典)

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

从 infer.py 加载 InferClass。InferClass 应在 “scripts/infer.py” 路径下的模板中定义。需要定义“InferClass”（名称是固定的），并且至少有两个函数（__init__ 和 infer）。init 类有一个覆盖 kwargs，可选择用于在运行时覆盖参数。

示例

class InferClass
    def __init__(self, config_file: Optional[Union[str, Sequence[str]]] = None, **override):
        # read configs from config_file (sequence)
        # set up transforms
        # set up model
        # set up other hyper parameters
        return

    @torch.no_grad()
    def infer(self, image_file):
        # infer the model and save the results to output
        return output

get_output_path()[source]#: 返回算法输出路径以查找算法脚本和配置。

get_score(*args, **kwargs)[source]#: 返回当前算法训练的模型验证分数。

pre_check_skip_algo(skip_bundlegen=False, skip_info='')[source]#

分析数据分析报告并检查是否需要跳过该算法。此函数在算法内部被覆盖。:type skip_bundlegen: bool :param skip_bundlegen: 如果为 True，则跳过为该算法生成捆绑包。:type skip_info: str :param skip_info: 跳过时要打印的信息。

返回类型:: tuple[bool, str]

predict(predict_files, predict_params=None)[source]#

使用训练好的模型预测给定输入图像的输出。

参数:

predict_files – 要运行推理的文件路径列表 [“path_to_image_1”, “path_to_image_2”]
predict_params – 用于覆盖捆绑配置（包括要预测的文件）中参数的字典。

set_data_source(data_src_cfg)[source]#

设置数据源配置文件

参数:: data_src_cfg (str) – 包含数据列表、数据根目录和其他参数的配置文件（yaml）的路径。配置格式为 {“modality”: “ct”, “datalist”: “path_to_json_datalist”, “dataroot”: “path_dir_data”}
返回类型:: None

set_data_stats(data_stats_files)[source]#

设置数据分析报告（由 DataAnalyzer 生成）。

参数:: data_stats_files (str) – 数据统计 yaml 文件的路径。
返回类型:: None

set_mlflow_experiment_name(mlflow_experiment_name)[source]#

设置 MLflow 服务器的实验名称。

参数:: mlflow_experiment_name – 指定 MLflow 服务器实验名称的字符串。

set_mlflow_tracking_uri(mlflow_tracking_uri)[source]#

设置 MLflow 服务器的跟踪 URI。

参数:: mlflow_tracking_uri – MLflow 服务器的跟踪 URI，可以是本地目录或远程跟踪服务器的地址；如果值为 None，MLflow 运行将记录在算法的模型文件夹中。

train(train_params=None, device_setting=None)[source]#

加载每个模型的训练脚本中的 run 函数。训练参数由 algo_config.yaml 文件预定义，该文件由同一实例中的 fill_template_config 函数预填充。

参数:

train_params – 训练参数。
device_setting – 设备相关设置，应遵循 auto_runner.set_device_info 中的 device_setting。‘CUDA_VISIBLE_DEVICES’ 应是一个字符串，例如 ‘0,1,2,3’。

class monai.apps.auto3dseg.BundleGen(algo_path='.', algos=None, templates_path_or_url=None, data_stats_filename=None, data_src_cfg_name=None, mlflow_tracking_uri=None, mlflow_experiment_name=None)[source]#

此类根据交叉验证折数生成一组捆绑包，每个捆绑包都可以独立运行。

参数:

algo_path – 保存算法模板的目录路径。默认为当前工作目录。
algos – 如果是字典，则概述要使用的算法。如果是列表或字符串，则定义要使用的算法名称子集，例如 templates_path_or_url 提供的所有算法模板中的 (‘segresnet’, ‘dints’)。默认为 None - 使用所有可用算法。
templates_path_or_url – 包含算法模板的文件夹或 URL。如果未提供 None，将下载默认模板 zip URL 并提取到 algo_path 中。当前的默认选项发布在：Project-MONAI/research-contributions。
data_stats_filename – 数据统计文件（由 DataAnalyzer 生成）的路径。
data_src_cfg_name – 数据源配置 YAML 文件的路径。配置格式为 {“modality”: “ct”, “datalist”: “path_to_json_datalist”, “dataroot”: “path_dir_data”}。
mlflow_tracking_uri – MLflow 服务器的跟踪 URI，可以是本地目录或远程跟踪服务器的地址；如果值为 None，MLflow 运行将记录在算法的模型文件夹中。
mlfow_experiment_name – 指定 MLflow 服务器实验名称的字符串。

python -m monai.apps.auto3dseg BundleGen generate --data_stats_filename="../algorithms/datastats.yaml"

generate(output_folder='.', num_fold=5, gpu_customization=False, gpu_customization_specs=None, allow_skip=True)[source]#

为每个 bundleAlgo 生成捆绑包脚本/配置。

参数:

output_folder – 保存每个算法的输出文件夹。
num_fold – 交叉验证折数。
gpu_customization – 用于根据 GPU 自动确定是否为每个 bundleAlgo 自定义/优化捆绑包脚本/配置参数的开关。自定义参数通过模拟实际模型训练过程和超参数优化（HPO）实验的模拟训练获得。
gpu_customization_specs – 允许用户覆盖 HPO 设置的字典。用户可以覆盖部分变量如下所示或全部覆盖。结构如下。

allow_skip –

一个开关，用于根据 Auto3DSeg DataAnalyzer 对数据集的分析，确定是否可以跳过默认模板中的某些算法。

gpu_customization_specs = {
    'ALGO': {
        'num_trials': 6,
        'range_num_images_per_batch': [1, 20],
        'range_num_sw_batch_size': [1, 20]
    }
}

ALGO –
算法名称。可以是某个算法名称（例如 ‘dints’），也可以是 ‘universal’，后者将更改应用于所有算法。可能的选项包括
- {"universal", "dints", "segresnet", "segresnet2d", "swinunetr"}。
num_trials – 要运行的 HPO 试验/实验次数。
range_num_images_per_batch – 每个 mini-batch 的图像数量范围。
range_num_sw_batch_size – 滑动窗口 inferer 中的批量大小范围。

get_data_src()[source]#: 获取数据源文件名。

get_data_stats()[source]#: 获取数据统计的文件名。

get_history()[source]#

获取 bundleAlgo 对象的历史记录及其名称/标识符。

返回类型:: list (列表)

get_mlflow_experiment_name()[source]#: 获取 MLflow 服务器的实验名称。

get_mlflow_tracking_uri()[source]#: 获取 MLflow 服务器的跟踪 URI。

set_data_src(data_src_cfg_name)[source]#

设置数据源文件名。

参数:: data_src_cfg_name – 数据源文件的文件名。

set_data_stats(data_stats_filename)[source]#

设置数据统计文件名。

参数:: data_stats_filename (str) – 数据统计文件名。
返回类型:: None

set_mlflow_experiment_name(mlflow_experiment_name)[source]#

设置 MLflow 服务器的实验名称。

参数:: mlflow_experiment_name – 指定 MLflow 服务器实验名称的字符串。

set_mlflow_tracking_uri(mlflow_tracking_uri)[source]#

设置 MLflow 服务器的跟踪 URI。

参数:: mlflow_tracking_uri – MLflow 服务器的跟踪 URI，可以是本地目录或远程跟踪服务器的地址；如果值为 None，MLflow 运行将记录在算法的模型文件夹中。

class monai.apps.auto3dseg.DataAnalyzer(datalist, dataroot='', output_path='./datastats.yaml', average=True, do_ccp=False, device='cuda', worker=4, image_key='image', label_key='label', hist_bins=0, hist_range=None, fmt='yaml', histogram_only=False, **extra_params)[source]#

DataAnalyzer 自动分析给定的医学图像数据集并报告统计数据。该模块需要图像数据的文件路径，并利用 LoadImaged 变换读取文件，支持 nii、nii.gz、png、jpg、bmp、npz、npy 和 dcm 格式。目前，仅支持分割任务，因此用户需要提供图像和标签文件（如果有）的路径。此外，标签数据格式首选为 (1,H,W,D)，标签索引位于第一个维度。如果为 onehot 格式，则会转换为首选格式。

参数:

datalist – 一个 Python 字典，存储医学图像数据集的分组、折叠和其他信息，或指向存储该字典的 JSON 文件的字符串。
dataroot – 用户本地包含数据集的目录。
output_path – 保存分析结果的路径。
average – 是否平均不同图像模态的统计值。
do_ccp – 应用连通分量算法处理标签/图像。
device – 指定操作所使用的硬件（CUDA/CPU）的字符串。
worker – 在每个 GPU/CPU 子进程中用于加载数据集的工作进程数。
image_key – 用户为图像指定的字符串。DataAnalyzer 将在数据列表中查找它以定位数据集的图像文件。
label_key – 用户为标签指定的字符串。DataAnalyzer 将在数据列表中查找它以定位数据集的标签文件。如果 label_key 是 NoneType 或 “None”，DataAnalyzer 将跳过查找标签以及所有与标签相关的操作。
hist_bins – 计算每个图像通道直方图的 bin。
hist_range – 计算每个图像通道直方图的范围。
fmt – 用于保存分析结果的格式。目前支持 "json" 和 "yaml"，默认为 “yaml”。
histogram_only – 是否仅计算直方图。默认为 False。
extra_params – 其他可选参数。目前支持的参数有：“allowed_shape_difference”（默认为 5）可用于更改图像和标签项之间允许的形状差异的默认容差。如果形状不匹配且在容差范围内，标签图像将使用最近邻插值法调整大小以匹配图像。

示例

from monai.apps.auto3dseg.data_analyzer import DataAnalyzer

datalist = {
    "testing": [{"image": "image_003.nii.gz"}],
    "training": [
        {"fold": 0, "image": "image_001.nii.gz", "label": "label_001.nii.gz"},
        {"fold": 0, "image": "image_002.nii.gz", "label": "label_002.nii.gz"},
        {"fold": 1, "image": "image_001.nii.gz", "label": "label_001.nii.gz"},
        {"fold": 1, "image": "image_004.nii.gz", "label": "label_004.nii.gz"},
    ],
}

dataroot = '/datasets' # the directory where you have the image files (nii.gz)
DataAnalyzer(datalist, dataroot)

注意

该模块也可以通过命令行接口（CLI）调用。

例如

python -m monai.apps.auto3dseg \
    DataAnalyzer \
    get_all_case_stats \
    --datalist="my_datalist.json" \
    --dataroot="my_dataroot_dir"

get_all_case_stats(key='training', transform_list=None)[source]#

获取所有病例统计数据。DataAnalyser 类的调用者。该函数启动内部 _get_all_case_stats 函数的多个 GPU 或 CPU 进程，这些进程迭代数据列表并调用 SegSummarizer 为每个病例生成统计数据。生成所有病例统计数据后，调用 SegSummarizer 合并结果。返回

参数:

key – 数据集键。
transform_list – SegSummarizer 之前的可选变换列表。

返回:

包含数据统计信息的字典。: ”stats_summary”（整个数据集的摘要统计）。在 stats_summary 中包含“image_stats”（使用 operations_summary 汇总形状、通道、间距等信息）、“image_foreground_stats”（非零标记体素的强度信息）和“label_stats”（标签信息、像素百分比、图像强度以及列表中的每个单独标签）。“stats_by_cases”（列表类型值。列表的每个元素是一个图像-标签信息的统计数据。在每个元素中包含：“image”（值是图像的路径）、“label”（值是相应标签的路径）、“image_stats”（使用 operations 汇总形状、通道、间距等信息）、“image_foreground_stats”（类似于前一个，但是一个前景图像）和“label_stats”（单个标签的统计数据））。

注意

由于统计计算的后端是 torch/numpy，计算中可能会生成和传递 nan/inf 值。在这种情况下，输出字典将在统计数据中包含 .nan/.inf。

class monai.apps.auto3dseg.EnsembleRunner(data_src_cfg_name, work_dir='./work_dir', num_fold=5, ensemble_method_name='AlgoEnsembleBestByFold', mgpu=True, **kwargs)[source]#

集成器的运行器。它集成预测结果并将它们保存到磁盘，并支持使用多 GPU。

参数:

data_src_cfg_name (str) – 数据源的文件名。
work_dir (str) – 保存中间和最终结果的工作目录。默认为 ./work_dir。
num_fold (int) – 折叠数。默认为 5。
ensemble_method_name (str) – 用于集成不同模型预测结果的方法。默认为 AlgoEnsembleBestByFold。支持的方法：[“AlgoEnsembleBestN”, “AlgoEnsembleBestByFold”]。
mgpu (bool) – 是否使用多 GPU。默认为 True。
kwargs (Any) – 用于集成推理的额外图像写入、集成参数和预测参数。- 对于图像保存，请查阅 SaveImage 变换中支持的参数。- 对于预测参数，请查阅 AlgoEnsemble 可调用对象中支持的参数。- 对于集成参数，请查阅所选 AlgoEnsemble 可调用对象的文档。

示例

ensemble_runner = EnsembleRunner(data_src_cfg_name,
                                 work_dir,
                                 ensemble_method_name,
                                 mgpu=device_setting['n_devices']>1,
                                 **kwargs,
                                 **pred_params)
ensemble_runner.run(device_setting)

run(device_setting=None)[source]#

加载每个模型的训练脚本中的 run 函数。训练参数由 algo_config.yaml 文件预定义，该文件由同一实例中的 fill_template_config 函数预填充。

参数:: device_setting – 设备相关设置，应遵循 auto_runner.set_device_info 中的 device_setting。‘CUDA_VISIBLE_DEVICES’ 应是一个字符串，例如 ‘0,1,2,3’。

set_ensemble_method(ensemble_method_name='AlgoEnsembleBestByFold', **kwargs)[source]#

设置捆绑包集成方法。

参数:

ensemble_method_name (str) – 集成方法的名称。仅支持两种方法：“AlgoEnsembleBestN” 和 “AlgoEnsembleBestByFold”。
kwargs (Any) – 用于定义集成方法的关键字参数。目前仅支持用于 AlgoEnsembleBestN 的 n_best。

返回类型:

None

set_image_save_transform(**kwargs)[source]#

设置集成输出变换。

参数:: kwargs (Any) – 集成推理的图像写入参数。kwargs 格式遵循 SaveImage 变换。有关更多信息，请查看 https://docs.monai.org.cn/en/stable/transforms.html#saveimage 。
返回类型:: None

set_num_fold(num_fold=5)[source]#

设置所有算法的交叉验证折数。

参数:: num_fold (int) – 定义折数的正整数。
返回类型:: None

class monai.apps.auto3dseg.NNIGen(algo=None, params=None)[source]#

为 NNI 生成算法以自动化超参数调优。该模块有两个主要接口：__init__，它打印出如何设置 NNI；以及一个 run_algo trialCommand 函数，用于 NNI 库启动算法试运行。有关 trialCommand 函数的更多信息，请参阅 NNI 网页的 trail code 部分 https://nni.readthedocs.io/en/stable/tutorials/hpo_quickstart_pytorch/main.html 。

参数:

algo – 一个算法对象（例如 BundleAlgo），具有定义的方法：get_output_path 和 train，并支持通过 algo_from_pickle 和 algo_to_pickle 保存到 pickle 文件和从 pickle 文件加载。
params – 一组参数，如果算法子类支持覆盖，则用于覆盖算法。

示例

The experiment will keep generating new folders to save the model checkpoints, scripts, and configs if available.
├── algorithm_templates
│   └── unet
├── unet_0
│   ├── algo_object.pkl
│   ├── configs
│   └── scripts
├── unet_0_learning_rate_0.01
│   ├── algo_object.pkl
│   ├── configs
│   ├── model_fold0
│   └── scripts
└── unet_0_learning_rate_0.1
    ├── algo_object.pkl
    ├── configs
    ├── model_fold0
    └── scripts

.. code-block:: python
    # Bundle Algorithms are already generated by BundleGen in work_dir
    import_bundle_algo_history(work_dir, only_trained=False)
    algo_dict = self.history[0]  # pick the first algorithm
    algo_name = algo_dict[AlgoKeys.ID]
    onealgo = algo_dict[AlgoKeys.ALGO]
    nni_gen = NNIGen(algo=onealgo)
    nni_gen.print_bundle_algo_instruction()

注意

NNIGen 将在一个文件夹中准备算法，并建议一个命令来替换实验配置中的 trialCommand。然而，NNIGen 不会触发 NNI。用户需要编写他们的 NNI 实验配置，然后手动运行 NNI 命令。

generate(output_folder='.')[source]#

为每个算法生成记录。如果它是 BundleAlgo，它将生成配置文件。

参数:: output_folder (str) – nni 将保存结果的目录。
返回类型:: None

get_hyperparameters()[source]#: 从 NNI 服务器获取下一轮训练的参数。

get_obj_filename()[source]#: 返回已 dump 的 pickle 算法对象的文件名。

get_task_id()[source]#: 获取当前实验的标识符。格式为在文件名中以下划线连接搜索参数名称和值。

print_bundle_algo_instruction()[source]#: 打印如何为 Bundle Algo 编写试运行命令。

run_algo(obj_filename, output_folder='.', template_path=None)[source]#

NNI 运行的 python 接口。

参数:

obj_filename – pickle 导出的算法对象。
output_folder – 算法模板的根路径。
template_path – 算法模板。它必须在以下路径中包含 algo.py：{algorithm_templates_dir}/{network}/scripts/algo.py

set_score(acc)[source]#: 向 NNI 服务器报告 acc。

update_params(params)[source]#

转换 monai 捆绑包中的参数以满足 NNI 的要求。

参数:: params (dict) – 一个参数字典。
返回类型:: None

class monai.apps.auto3dseg.OptunaGen(algo=None, params=None)[source]#

为 Optuna 生成算法以自动化超参数调优。有关更多信息，请参阅 NNI 和 Optuna (https://optuna.readthedocs.io/en/stable/)。Optuna 与 NNI 相比有不同的运行方案。超参数样本来自 Optuna 创建的 trial 对象 (trial.suggest…)，因此 OptunaGen 需要接受此 trial 对象作为输入。同时，Optuna 调用 OptunaGen，因此 OptunaGen.__call__() 应返回精度。使用 functools.partial 包装 OptunaGen 以添加输入参数。

参数:

algo – 一个算法对象（例如 BundleAlgo）。该对象必须至少定义两个方法：get_output_path 和 train，并支持通过 algo_from_pickle 和 algo_to_pickle 保存到 pickle 文件和从 pickle 文件加载。
params – 一组参数，如果算法子类支持覆盖，则用于覆盖算法。

示例

The experiment will keep generating new folders to save the model checkpoints, scripts, and configs if available.
├── algorithm_templates
│   └── unet
├── unet_0
│   ├── algo_object.pkl
│   ├── configs
│   └── scripts
├── unet_0_learning_rate_0.01
│   ├── algo_object.pkl
│   ├── configs
│   ├── model_fold0
│   └── scripts
└── unet_0_learning_rate_0.1
    ├── algo_object.pkl
    ├── configs
    ├── model_fold0
    └── scripts

注意

与 NNI 和 NNIGen 不同，OptunaGen 和 Optuna 可以在 Python 进程中运行。

__call__(trial, obj_filename, output_folder='.', template_path=None)[source]#

Optuna 将用于优化超参数的可调用对象。

参数:

obj_filename – pickle 导出的算法对象。
output_folder – 算法模板的根路径。
template_path – 算法模板。它必须在以下路径中包含 algo.py：{algorithm_templates_dir}/{network}/scripts/algo.py

generate(output_folder='.')[source]#

为每个算法生成记录。如果它是 BundleAlgo，它将生成配置文件。

参数:: output_folder (str) – nni 将保存结果的目录。
返回类型:: None

get_hyperparameters()[source]#: 从 optuna trial 对象获取下一轮训练的参数。对于不同的搜索空间，使用此函数时需要用户重新编写。

get_obj_filename()[source]#: 返回已 dump 的算法 pickle 对象。

get_task_id()[source]#: 获取当前实验的标识符。格式为在文件名中以下划线连接搜索参数名称和值。

run_algo(obj_filename, output_folder='.', template_path=None)[source]#

NNI 运行的 python 接口。

参数:

obj_filename – pickle 导出的算法对象。
output_folder – 算法模板的根路径。
template_path – 算法模板。它必须在以下路径中包含 algo.py：{algorithm_templates_dir}/{network}/scripts/algo.py

set_score(acc)[source]#: 设置精度分数。

set_trial(trial)[source]#: 设置 Optuna trial。

update_params(params)[source]#

转换 monai 捆绑包中的参数。

参数:: params (dict) – 一个参数字典。
返回类型:: None

monai.apps.auto3dseg.export_bundle_algo_history(history)[source]#

将历史记录中的所有 BundleAlgo 保存到每个单独文件夹中的 algo_object.pkl 文件。

参数:: history (list[dict[str, BundleAlgo]]) – Bundle 列表。通常，历史记录可以从 BundleGen 的 get_history 方法获取。
返回类型:: None

monai.apps.auto3dseg.get_name_from_algo_id(id)[source]#

从算法的标识符获取算法名称。

参数:: id (str) – 遵循“name_fold_other”约定的标识符。
返回类型:: str (字符串)
返回:: 算法的名称。

monai.apps.auto3dseg.import_bundle_algo_history(output_folder='.', template_path=None, only_trained=True)[source]#

导入 bundleAlgo 对象的历史记录，作为算法字典列表。每个 algo_dict 具有键 name（文件夹名）、algo（bundleAlgo）、is_trained（布尔值）。

参数:

output_folder – 算法模板的根路径。
template_path – 算法模板。它必须在以下路径中包含 algo.py：{algorithm_templates_dir}/{network}/scripts/algo.py。
only_trained – 仅当算法已训练时才读取算法历史记录。

nnUNet#

class monai.apps.nnunet.nnUNetV2Runner(input_config, trainer_class_name='nnUNetTrainer', work_dir='work_dir', export_validation_probabilities=True)[source]#

nnUNetV2Runner 在 MONAI 中提供了一个接口，用于使用 nnU-Net V2 库来分析、训练和评估用于医学图像分割任务的神经网络。此类别需要 nnunetv2 版本高于 2.2。

nnUNetV2Runner 可以通过两种方式使用：

使用一行代码执行完整的流水线。
使用一系列命令运行流水线中的每个模块。

接口的输出是一个目录，其中包含

转换后的数据集符合 nnU-Net V2 的要求
数据分析结果
训练好的 U-Net 模型的检查点
交叉验证每个折叠中的验证精度
最终算法集成对测试数据集的预测以及潜在的后处理

参数:

input_config (Any) – 配置字典或 YAML 格式的配置文件路径。配置中需要的键是：- "datalist"：用于训练/测试分割的数据列表文件路径。- "dataroot"：数据集文件路径。- "modality"：成像模态，例如“CT”，[“T2”, “ADC”]。目前，配置支持以下可选键：- "nnunet_raw"：将写入 nnU-Net 环境变量的文件路径。- "nnunet_preprocessed"：将写入 nnU-Net 环境变量的文件路径。- "nnunet_results"：将写入 nnU-Net 环境变量的文件路径。- "nnUNet_trained_models"。- "dataset_name_or_id"：数据集的名称或整数 ID。如果未指定可选键，流水线将使用默认值。
trainer_class_name (str) – nnUNetV2 提供的训练器类名称在训练持续时间上有所不同。默认值：“nnUNetTrainer”。其他选项：“nnUNetTrainer_Xepoch”。X 可以是 1,5,10,20,50,100, 250,2000,4000,8000 中的一个。
export_validation_probabilities (bool) – 如果为 True，则将最终验证的 softmax 预测保存为 npz 文件（除了预测的分割结果）。找到最佳集成所必需。默认值：True。
work_dir (str) – 保存中间和最终结果的工作目录。

示例

使用一行命令启动 nnU-Net 工作流程。

python -m monai.apps.nnunet nnUNetV2Runner run --input_config ./input.yaml

使用 convert_dataset 准备数据以满足 nnU-Net 的要求，生成数据集 JSON 文件，
并将数据集复制到输入配置文件中 nnunet_raw 指定的位置。

python -m monai.apps.nnunet nnUNetV2Runner convert_dataset --input_config="./input.yaml"

如果数据集是 MSD，convert_msd_dataset 是准备数据的另一种选择。

python -m monai.apps.nnunet nnUNetV2Runner convert_msd_dataset \
    --input_config "./input.yaml" --data_dir "/path/to/Task09_Spleen"

实验规划和数据预处理。

python -m monai.apps.nnunet nnUNetV2Runner plan_and_process --input_config "./input.yaml"

使用所有可用 GPU 训练所有 20 个模型。
不支持“CUDA_VISIBLE_DEVICES”环境变量。

python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml"

在单个 GPU 上训练单个模型 5 个 epoch。这里使用 config 指定配置。

python -m monai.apps.nnunet nnUNetV2Runner train_single_model --input_config "./input.yaml" \
    --config "3d_fullres" \
    --fold 0 \
    --gpu_id 0 \
    --trainer_class_name "nnUNetTrainer_5epochs" \
    --export_validation_probabilities True

在 2 个 GPU 上训练所有 20 个模型（4 种配置 x 5 折叠）。

python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml" --gpu_id_for_all "0,1"

在 2 个 GPU 上对单个模型进行 5 折叠训练。这里使用 configs 指定配置。

python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml" \
    --configs "3d_fullres" \
    --trainer_class_name "nnUNetTrainer_5epochs" \
    --export_validation_probabilities True \
    --gpu_id_for_all "0,1"

查找最佳配置。

python -m monai.apps.nnunet nnUNetV2Runner find_best_configuration --input_config "./input.yaml"

预测、集成和后处理。

python -m monai.apps.nnunet nnUNetV2Runner predict_ensemble_postprocessing --input_config "./input.yaml"

convert_dataset()[source]#: 转换数据集并创建副本以满足 nnU-Net 工作流程的要求。

convert_msd_dataset(data_dir, overwrite_id=None, n_proc=-1)[source]#

转换 MSD 数据集并创建副本以满足 nnU-Net 工作流程的要求。

参数:

data_dir – 下载并解压的 MSD 数据集文件夹。不能是 nnUNetv1 数据集！示例：“/workspace/downloads/Task05_Prostate”。
overwrite_id – 覆盖数据集 ID。如果未设置，则使用 MSD 任务的 ID（从文件夹名称推断）。仅在您已经有一个同等编号的数据集时才使用此选项！
n_proc – 使用的进程数。

extract_fingerprints(fpe='DatasetFingerprintExtractor', npfp=-1, verify_dataset_integrity=False, clean=False, verbose=False)[source]#

提取用于实验规划的数据集指纹。

参数:

fpe (str) – [可选] 应使用的 Dataset Fingerprint Extractor 类名称。默认值为“DatasetFingerprintExtractor”。
npfp (int) – [可选] 用于指纹提取的进程数。
verify_dataset_integrity (bool) – [推荐] 设置此标志以检查数据集完整性。这很有用，每个数据集应执行一次！
clean (bool) – [可选] 设置此标志以覆盖现有指纹。如果未设置此标志且指纹已存在，则指纹提取器将不会运行。
verbose (bool) – 设置此项以打印大量信息。对调试很有用。这将禁用进度条！推荐用于集群环境。

返回类型:

None

find_best_configuration(plans='nnUNetPlans', configs=(2d, 3d_fullres, 3d_lowres, 3d_cascade_fullres), trainers=None, allow_ensembling=True, num_processes=-1, overwrite=True, folds=(0, 1, 2, 3, 4), strict=False)[source]#

查找最佳模型配置。

参数:

plans – 计划标识符列表。默认值：nnUNetPlans。
configs – 配置列表。默认值：[“2d”, “3d_fullres”, “3d_lowres”, “3d_cascade_fullres”]。
trainers – 训练器列表。默认值：nnUNetTrainer。
allow_ensembling – 设置此标志以启用集成。
num_processes – 用于集成、后处理等的进程数。
overwrite – 如果设置，我们将覆盖已集成的文件等。可能会加快此命令的连续运行（不推荐），但有未更新过时结果的风险。
folds – 要使用的折叠。默认值：(0, 1, 2, 3, 4)。
strict – 如果找不到日志文件夹，则触发 RunTimeError 的开关。默认值：False。

plan_and_process(fpe='DatasetFingerprintExtractor', npfp=8, verify_dataset_integrity=False, no_pp=False, clean=False, pl='ExperimentPlanner', gpu_memory_target=8, preprocessor_name='DefaultPreprocessor', overwrite_target_spacing=None, overwrite_plans_name='nnUNetPlans', c=(2d, 3d_fullres, 3d_lowres), n_proc=(8, 8, 8), verbose=False)[source]#

在训练前执行实验规划和预处理。

参数:

fpe (str) – [可选] 应使用的 Dataset Fingerprint Extractor 类名称。默认值为“DatasetFingerprintExtractor”。
npfp (int) – [可选] 用于指纹提取的进程数。默认值：8。
verify_dataset_integrity (bool) – [推荐] 设置此标志以检查数据集完整性。这很有用，每个数据集应执行一次！
no_pp (bool) – [可选] 设置此项以仅运行指纹提取和实验规划（不进行预处理）。对调试很有用。
clean (bool) – [可选] 设置此标志以覆盖现有指纹。如果未设置此标志且指纹已存在，则指纹提取器将不会运行。如果您更改了 DATASET FINGERPRINT EXTRACTOR 或对数据集进行了更改，则这是必需的！
pl (str) – [可选] 应使用的 Experiment Planner 类名称。默认值为“ExperimentPlanner”。注意：2D 和 3D planner 之间不再有区别。现在是全功能解决方案。
gpu_memory_target (int) – [可选] 危险区域！设置自定义 GPU 内存目标。默认值：8 [GB]。更改此值将影响 patch 和 batch 大小，并且肯定会影响您模型的性能！仅在您真正了解自己在做什么时才使用此选项，切勿在未首先运行默认 nnU-Net（作为基准）的情况下使用此选项。
preprocessor_name (str) – [可选] 危险区域！设置自定义预处理类。此类必须位于 nnunetv2.preprocessing 中。默认值：“DefaultPreprocessor”。更改此值可能会影响您模型的性能！仅在您真正了解自己在做什么时才使用此选项，切勿在未首先运行默认 nnU-Net（作为基准）的情况下使用此选项。
overwrite_target_spacing (Optional[Any]) – [可选] 危险区域！为 3d_fullres 和 3d_cascade_fullres 配置设置自定义目标间距。默认值：None [无更改]。更改此值将影响图像大小以及潜在的 patch 和 batch 大小。这肯定会影响您模型的性能！仅在您真正了解自己在做什么时才使用此选项，切勿在未首先运行默认 nnU-Net（作为基准）的情况下使用此选项。目前尚未实现更改其他配置的目标间距。新的目标间距必须是包含三个数字的列表！
overwrite_plans_name (str) – [可选] 使用自定义计划标识符。如果您使用了 -gpu_memory_target、-preprocessor_name 或 -overwrite_target_spacing，最佳实践是使用 -overwrite_plans_name 生成一个不同名称的计划文件，以便不会覆盖 nnunet 默认计划。然后，在运行其他 nnunet 命令（训练、推理等）时，您需要使用 -p 指定您的自定义计划文件。
c (tuple) – [可选] 应运行预处理的配置。默认值：2d 3f_fullres 3d_lowres。无需指定 3d_cascade_fullres，因为它使用 3f_fullres 的数据。某些数据集不存在的配置将被跳过。
n_proc (tuple) – [可选] 使用此参数定义要使用的进程数。如果只有一个数字，则将此数量的进程用于使用 -c 指定的所有配置。如果是一个数字列表，则此列表必须与配置数量相同。然后我们遍历 zip(configs, num_processes) 来确定每个配置使用的进程数。更多进程总是更快（直到您的 PC 支持的线程数，例如具有超线程的 4 核 CPU 为 8 个）。如果您不知道那是什么，请不要更改它，或者至少不要增加它！危险：通常可以使用进程数受可用 RAM 数量的限制。图像重采样占用大量 RAM。如果您的 RAM 占用过多，请监控 RAM 使用情况并减少 -n_proc！默认值：8 4 8（=如果 -c 为默认值，则 2D 使用 8 个进程，3d_fullres 使用 4 个，3d_lowres 使用 8 个）。
verbose (bool) – 设置此项以打印大量信息。对调试很有用。这将禁用进度条！(推荐用于集群环境)。

返回类型:

None

plan_experiments(pl='ExperimentPlanner', gpu_memory_target=8, preprocessor_name='DefaultPreprocessor', overwrite_target_spacing=None, overwrite_plans_name='nnUNetPlans')[source]#

生成一个配置文件，用于指定实验的详细信息。

参数:

pl (str) – [可选] 应使用的 Experiment Planner 类名称。默认值为“ExperimentPlanner”。注意：2D 和 3D planner 之间不再有区别。现在是全功能解决方案。
gpu_memory_target (float) – [可选] 危险区域！设置自定义 GPU 内存目标。默认值：8 [GB]。更改此设置将影响 patch 和 batch 大小，并且肯定会影响模型的性能！仅在您非常清楚自己在做什么时才使用此选项，并且切勿在未先运行默认 nnU-Net（作为基准）的情况下使用此选项。
preprocessor_name (str) – [可选] 危险区域！设置自定义预处理类。此类必须位于 nnunetv2.preprocessing 中。默认值：“DefaultPreprocessor”。更改此值可能会影响您模型的性能！仅在您真正了解自己在做什么时才使用此选项，切勿在未首先运行默认 nnU-Net（作为基准）的情况下使用此选项。
overwrite_target_spacing (Optional[Any]) – [可选] 危险区域！为 3d_fullres 和 3d_cascade_fullres 配置设置自定义目标间距。默认值：None [无更改]。更改此设置将影响图像大小，并可能影响 patch 和 batch 大小。这肯定会影响模型的性能！仅在您非常清楚自己在做什么时才使用此选项，并且切勿在未先运行默认 nnU-Net（作为基准）的情况下使用此选项。目前未实现更改其他配置的目标间距。新的目标间距必须是包含三个数字的列表！
overwrite_plans_name (str) – [可选] 危险区域！如果您使用了 -gpu_memory_target、-preprocessor_name 或 -overwrite_target_spacing，则最佳做法是使用 -overwrite_plans_name 生成不同名称的 plans 文件，以便不会覆盖 nnunet 默认计划。然后，您将需要指定您的自定义计划。

返回类型:

None

predict(list_of_lists_or_source_folder, output_folder, model_training_output_dir, use_folds=None, tile_step_size=0.5, use_gaussian=True, use_mirroring=True, perform_everything_on_gpu=True, verbose=True, save_probabilities=False, overwrite=True, checkpoint_name='checkpoint_final.pth', folder_with_segs_from_prev_stage=None, num_parts=1, part_id=0, num_processes_preprocessing=-1, num_processes_segmentation_export=-1, gpu_id=0)[source]#

使用此函数运行 nnU-Net 推理。当您希望手动指定包含: 一个训练好的 nnU-Net 模型。当未设置 nnunet 环境变量 (nnUNet_results) 时，此功能非常有用。

参数:

list_of_lists_or_source_folder – 输入文件夹。请记住为文件使用正确的通道编号（例如 _0000）。文件后缀必须与训练数据集相同！
output_folder – 输出文件夹。如果该文件夹不存在，将创建它。预测的分割结果将与其源图像具有相同的名称。
model_training_output_dir – 训练好的模型所在的文件夹。必须包含用于存放您训练的不同折叠的子文件夹 fold_X。
use_folds – 指定应用于预测的训练模型的折叠。默认值：(0, 1, 2, 3, 4)。
tile_step_size – 滑动窗口预测的步长。值越大，预测速度越快但准确性越低。默认值：0.5。不能大于 1。我们建议使用默认值。
use_gaussian – 使用高斯平滑作为测试时增强。
use_mirroring – 使用镜像/翻转作为测试时增强。
verbose – 如果您希望看到详细输出，请设置此选项。您需要仔细查看/阅读。
save_probabilities – 设置此选项可导出预测的类别“概率”。如果要集成多个配置，则需要此选项。
overwrite – 覆盖现有的先前预测（不会覆盖已存在的文件）
checkpoint_name – 要使用的检查点名称。默认值：checkpoint_final.pth。
folder_with_segs_from_prev_stage – 包含前一阶段预测结果的文件夹。级联模型需要此选项。
num_parts – 您将进行的独立 nnUNetv2_predict 调用次数。默认值：1（= 此一次调用预测所有内容）。
part_id – 如果存在多个 nnUNetv2_predict 调用，这是其中的哪一个？ID 从 0 开始，到 num_parts - 1 结束。因此，当您提交 5 个 nnUNetv2_predict 调用时，需要设置 -num_parts 5 并使用 -part_id 0, 1, 2, 3 和 4。
num_processes_preprocessing – 处理预处理的进程数。
num_processes_segmentation_export – 用于分割导出的进程数。越多不一定越好。请注意内存不足问题。
gpu_id – 用于预测的 GPU ID。

predict_ensemble_postprocessing(folds=(0, 1, 2, 3, 4), run_ensemble=True, run_predict=True, run_postprocessing=True, **kwargs)[source]#

可选地运行预测、集成和/或后处理。

参数:

folds (tuple) – 要使用的折叠
run_ensemble (bool) – 是否运行集成。
run_predict (bool) – 是否使用训练好的检查点进行预测
run_postprocessing (bool) – 是否执行后处理
kwargs (Any) – 此可选参数允许您指定在以下方法中定义的附加参数 predict 方法。

返回类型:

None

preprocess(c=(2d, 3d_fullres, 3d_lowres), n_proc=(8, 8, 8), overwrite_plans_name='nnUNetPlans', verbose=False)[source]#

在训练前对输入数据应用一组预处理操作。

参数:

overwrite_plans_name (str) – [可选] 您可以使用此选项指定您可能已生成的自定义计划文件。
c (tuple) – [可选] 应运行预处理的配置。默认值：2d 3f_fullres 3d_lowres。不需要指定 3d_cascade_fullres，因为它使用 3f_fullres 的数据。某些数据集中不存在的配置将被跳过)。
n_proc (tuple) – [可选] 使用此参数定义要使用的进程数。如果只有一个数字，则将此数量的进程用于使用 -c 指定的所有配置。如果是一个数字列表，则此列表必须与配置数量相同。然后我们遍历 zip(configs, num_processes) 来确定每个配置使用的进程数。更多进程总是更快（直到您的 PC 支持的线程数，例如具有超线程的 4 核 CPU 为 8 个）。如果您不知道那是什么，请不要更改它，或者至少不要增加它！危险：通常可以使用进程数受可用 RAM 数量的限制。图像重采样占用大量 RAM。如果您的 RAM 占用过多，请监控 RAM 使用情况并减少 -n_proc！默认值：8 4 8（=如果 -c 为默认值，则 2D 使用 8 个进程，3d_fullres 使用 4 个，3d_lowres 使用 8 个）。
verbose (bool) – 设置此选项可打印大量信息。有助于调试。将禁用进度条！建议在集群环境中使用。

返回类型:

None

run(run_convert_dataset=True, run_plan_and_process=True, run_train=True, run_find_best_configuration=True, run_predict_ensemble_postprocessing=True)[source]#

运行 nnU-Net 流水线。

参数:

run_convert_dataset (bool) – 是否转换数据集，默认为 True。
run_plan_and_process (bool) – 是否预处理和分析数据集，默认为 True。
run_train (bool) – 是否训练模型，默认为 True。
run_find_best_configuration (bool) – 是否查找最佳模型（集成）配置，默认为 True。
run_predict_ensemble_postprocessing (bool) – 是否对测试数据集进行预测，默认为 True。

返回类型:

None

train(configs=(3d_fullres, 2d, 3d_lowres, 3d_cascade_fullres), gpu_id_for_all=None, **kwargs)[source]#

运行由配置指定的所有模型的训练。注意：要设置使用的 GPU 数量，请使用 gpu_id_for_all 代替 CUDA_VISIBLE_DEVICES 环境变量。

参数:

configs – 应训练的配置。默认值：(“2d”, “3d_fullres”, “3d_lowres”, “3d_cascade_fullres”)。
gpu_id_for_all – 用于训练的 GPU 设备 ID（可以是元组/列表/整数）。默认值：None（所有可用 GPU）。
kwargs – 此可选参数允许您指定在以下方法中定义的附加参数 train_single_model 方法。

train_parallel(configs=(3d_fullres, 2d, 3d_lowres, 3d_cascade_fullres), gpu_id_for_all=None, **kwargs)[source]#

为并行训练创建子进程调用的命令行。注意：要设置使用的 GPU 数量，请使用 gpu_id_for_all 代替 CUDA_VISIBLE_DEVICES 环境变量。

参数:

configs – 应训练的配置。默认值：(“2d”, “3d_fullres”, “3d_lowres”, “3d_cascade_fullres”)。
gpu_id_for_all – 用于训练的 GPU 设备 ID（可以是元组/列表/整数）。默认值：None（所有可用 GPU）。
kwargs – 此可选参数允许您指定在以下方法中定义的附加参数 train_single_model 方法。

train_parallel_cmd(configs=(3d_fullres, 2d, 3d_lowres, 3d_cascade_fullres), gpu_id_for_all=None, **kwargs)[source]#

为并行训练创建子进程调用的命令行。

参数:

configs – 应训练的配置。默认值：(“2d”, “3d_fullres”, “3d_lowres”, “3d_cascade_fullres”)。
gpu_id_for_all – 用于训练的 GPU 设备 ID（可以是元组/列表/整数）。默认值：None（所有可用 GPU）。
kwargs – 此可选参数允许您指定在以下方法中定义的附加参数 train_single_model 方法。

train_single_model(config, fold, gpu_id=0, **kwargs)[source]#

在单个 GPU 上运行指定配置的模型训练。注意：这将覆盖环境变量 CUDA_VISIBLE_DEVICES。

参数:

config – 应训练的配置。示例：“2d”, “3d_fullres”, “3d_lowres”。
fold – 5 折交叉验证的折叠。应为 0 到 4 之间的整数。
gpu_id – 用于选择设备的整数，或用于多 GPU 训练的 GPU 设备索引的元组/列表（例如，(0,1)）。默认值：0。
kwargs –
此可选参数允许您在以下函数中指定附加参数 nnunetv2.run.run_training.run_training_entry。

当前支持的参数有
- p: 自定义计划标识符。默认值：“nnUNetPlans”。
- pretrained_weights: 用作预训练模型的 nnU-Net 检查点文件路径。仅当实际训练时才会
  使用。Beta 版本。请谨慎使用。默认值：False。
- use_compressed: 设置为 True 以使用压缩数据进行训练。读取压缩数据需要更多
  CPU 和（可能）RAM 资源，只有在您清楚自己在做什么时才应使用。默认值：False。
- c: 从最新的检查点继续训练。默认值：False。
- val: 设置为 True 以仅运行验证。要求训练已完成。
  默认值：False。
- disable_checkpointing: 设置为 True 以禁用检查点。非常适合测试，并且您
  不想用检查点淹没硬盘。默认值：False。

validate(configs=(3d_fullres, 2d, 3d_lowres, 3d_cascade_fullres), **kwargs)[source]#

对由配置定义的所有模型在 5 折交叉验证上执行验证。

参数:

configs (tuple) – 应训练的配置。默认值：(“2d”, “3d_fullres”, “3d_lowres”, “3d_cascade_fullres”)。
kwargs (Any) – 此可选参数允许您指定在以下方法中定义的附加参数 train_single_model 方法。

返回类型:

None

validate_single_model(config, fold, **kwargs)[source]#

对单个模型执行验证。

参数:

config (str) – 应训练的配置。
fold (int) – 5 折交叉验证的折叠。应为 0 到 4 之间的整数。
kwargs (Any) – 此可选参数允许您指定在以下方法中定义的附加参数 train_single_model 方法。

返回类型:

None