数据#
通用接口#
Dataset#
- class monai.data.Dataset(data, transform=None)[source]#
一个具有长度属性的通用数据集，并在获取数据样本时具有可选的可调用数据变换。如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
例如，典型的输入数据可以是字典列表
[{ { { 'img': 'image1.nii.gz', 'img': 'image2.nii.gz', 'img': 'image3.nii.gz', 'seg': 'label1.nii.gz', 'seg': 'label2.nii.gz', 'seg': 'label3.nii.gz', 'extra': 123 'extra': 456 'extra': 789 }, }, }]
IterableDataset#
- class monai.data.IterableDataset(data, transform=None)[source]#
一个用于可迭代数据源的通用数据集，并在获取数据样本时具有可选的可调用数据变换。继承自 PyTorch IterableDataset：https://pytorch.ac.cn/docs/stable/data.html?highlight=iterabledataset#torch.utils.data.IterableDataset。例如，典型的输入数据可以是支持多进程访问的网络数据流。
为了加速加载过程，它支持基于 PyTorch DataLoader worker 的多进程，每个进程对加载数据的部分执行变换。请注意：在多进程模式下，输出数据的顺序可能与数据源不匹配。每个 worker 进程将拥有数据集对象的不同副本，需要确保数据源或 DataLoader 的进程安全。
DatasetFunc#
- class monai.data.DatasetFunc(data, func, **kwargs)[source]#
在输入数据集上执行函数，并利用输出作为新的 Dataset。它可用于加载/获取基本数据集项，例如 image, label 路径列表。或链式调用以执行更复杂的逻辑，例如 partition_dataset, resample_datalist 等。Dataset 的 data 参数将应用于可调用对象 func 的第一个参数。用法示例
data_list = DatasetFunc( data="path to file", func=monai.data.load_decathlon_datalist, data_list_key="validation", base_dir="path to base dir", ) # partition dataset for every rank data_partition = DatasetFunc( data=data_list, func=lambda **kwargs: monai.data.partition_dataset(**kwargs)[torch.distributed.get_rank()], num_partitions=torch.distributed.get_world_size(), ) dataset = Dataset(data=data_partition, transform=transforms)
- 参数:
data (
Any) – 供 func 处理的输入数据，将作为 func 的第一个参数应用。func (
Callable) – 用于生成数据集项的可调用函数。kwargs – func 除第一个参数外的其他参数。
ShuffleBuffer#
- class monai.data.ShuffleBuffer(data, transform=None, buffer_size=512, seed=0, epochs=1)[source]#
扩展 IterableDataset，增加缓冲区并随机弹出项。
- 参数:
data – 输入数据源，用于加载和变换以生成模型所需数据集。
transform – 对输入数据进行变换的可调用对象。
buffer_size (
int) – 用于存储和随机弹出项的缓冲区大小，默认为 512。seed (
int) – 用于初始化所有 worker 的随机状态的随机种子，在每次 iter() 调用中设置 seed += 1，参考 PyTorch 的思路：pytorch/pytorch。epochs (
int) – 迭代数据集的 epoch 数，默认为 1，-1 表示无限 epoch。
注意
在运行时，
monai.data.DataLoader和torch.utils.data.DataLoader都不会对这个类（作为IterableDataset的子类）进行 seeding。persistent_workers=True标志（以及 pytorch>1.8）因此在num_workers>0时加载多个 epoch 是必需的。例如import monai def run(): dss = monai.data.ShuffleBuffer([1, 2, 3, 4], buffer_size=30, seed=42) dataloader = monai.data.DataLoader( dss, batch_size=1, num_workers=2, persistent_workers=True) for epoch in range(3): for item in dataloader: print(f"epoch: {epoch} item: {item}.") if __name__ == '__main__': run()
CSVIterableDataset#
- class monai.data.CSVIterableDataset(src, chunksize=1000, buffer_size=None, col_names=None, col_types=None, col_groups=None, transform=None, shuffle=False, seed=0, kwargs_read_csv=None, **kwargs)[source]#
用于加载 CSV 文件并生成字典数据的可迭代数据集。当数据来自流时特别有用，继承自 PyTorch IterableDataset：https://pytorch.ac.cn/docs/stable/data.html?highlight=iterabledataset#torch.utils.data.IterableDataset。
当加载无法直接读入内存的特大 CSV 文件时，它也很有帮助，只需将特大 CSV 文件视为流输入，每个 epoch 调用 CSVIterableDataset 的 reset()。请注意，作为流输入，它无法获取数据集的长度。
为了有效地打乱大数据集中的数据，用户可以设置一个大缓冲区来连续存储加载的数据，然后从缓冲区中随机选取数据用于后续任务。
为了加速加载过程，它支持基于 PyTorch DataLoader worker 的多进程，每个进程对加载数据的部分执行变换。注意：在多进程模式下，输出数据的顺序可能与数据源不匹配。
它可以从多个 CSV 文件加载数据，并使用额外的 kwargs 参数连接表格。支持仅加载特定列。它还可以将多个加载的列分组生成一个新列，例如，设置 col_groups={“meta”: [“meta_0”, “meta_1”, “meta_2”]}，输出可以是
[ {"image": "./image0.nii", "meta_0": 11, "meta_1": 12, "meta_2": 13, "meta": [11, 12, 13]}, {"image": "./image1.nii", "meta_0": 21, "meta_1": 22, "meta_2": 23, "meta": [21, 22, 23]}, ]
- 参数:
src – 如果提供 CSV 文件名，可以是 str、URL、路径对象或类文件对象进行加载。也支持直接为流输入提供迭代器，将跳过从文件名加载。如果提供文件名或迭代器列表，它将连接这些表。
chunksize – 从 CSV 文件加载可迭代数据时，每个 chunk 的行数，默认为 1000。更多详细信息：https://pandas.ac.cn/pandas-docs/stable/reference/api/pandas.read_csv.html。
buffer_size – 用于存储已加载 chunk 的缓冲区大小，如果为 None，则设置为 2 x chunksize。
col_names – 要加载的预期列名。如果为 None，则加载所有列。
col_types –
用于转换已加载列的 type 和 default value，如果为 None，则使用原始数据。它应该是一个字典，每个项映射到预期列，key 是列名，value 是 None 或一个定义默认值和数据类型的字典。字典中支持的键包括：[“type”, “default”]。例如
col_types = { "subject_id": {"type": str}, "label": {"type": int, "default": 0}, "ehr_0": {"type": float, "default": 0.0}, "ehr_1": {"type": float, "default": 0.0}, "image": {"type": str, "default": None}, }
col_groups – 用于将加载的列分组生成新列的参数，它应该是一个字典，每个项映射到一个组，key 将是新列名，value 是要组合的列名。例如：col_groups={“ehr”: [f”ehr_{i}” for i in range(10)], “meta”: [“meta_1”, “meta_2”]}
transform – 应用于加载的字典数据项的变换。
shuffle – 每次加载新 chunk 时是否打乱缓冲区中的所有数据。
seed – 如果 shuffle 为 True，则用于初始化所有 worker 随机状态的随机种子，在每次 iter() 调用中设置 seed += 1，参考 PyTorch 的思路：pytorch/pytorch。
kwargs_read_csv – 传递给 pandas read_csv 函数的字典参数。默认为
{"chunksize": chunksize}。kwargs – 用于 pandas.merge() API 连接表格的额外参数。
- close()[source]#
关闭 pandas TextFileReader 可迭代对象。如果输入 src 是文件路径，则 TextFileReader 是内部创建的，需要关闭。如果输入 src 是可迭代对象，则取决于用户在此函数中是否需要关闭它。更多详细信息，请查阅：https://pandas.ac.cn/pandas-docs/stable/user_guide/io.html?#iteration。
- reset(src=None)[source]#
重置 pandas TextFileReader 可迭代对象以读取数据。更多详细信息，请查阅：https://pandas.ac.cn/pandas-docs/stable/user_guide/io.html?#iteration。
- 参数:
src – 如果不为 None 且提供了 CSV 文件名，它可以是 str、URL、路径对象或类文件对象进行加载。也支持直接为流输入提供迭代器，将跳过从文件名加载。如果提供文件名或迭代器列表，它将连接这些表。默认为 self.src。
PersistentDataset#
- class monai.data.PersistentDataset(data, transform, cache_dir, hash_func=<function pickle_hashing>, pickle_module='pickle', pickle_protocol=2, hash_transform=None, reset_ops_id=True)[source]#
预计算值的持久化存储，以高效管理大于内存的字典格式数据，它可以对特定字段进行变换操作。非随机变换组件的结果在首次使用时计算，并存储在 cache_dir 中，以便后续快速检索。如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
应缓存的变换必须实现 monai.transforms.Transform 接口且不应是 Randomizable。此数据集将缓存 Compose 实例中第一个 Randomizable Transform 之前的结果。
例如，典型的输入数据可以是字典列表
[{ { { 'image': 'image1.nii.gz', 'image': 'image2.nii.gz', 'image': 'image3.nii.gz', 'label': 'label1.nii.gz', 'label': 'label2.nii.gz', 'label': 'label3.nii.gz', 'extra': 123 'extra': 456 'extra': 789 }, }, }]
对于复合变换，例如
[ LoadImaged(keys=['image', 'label']), Orientationd(keys=['image', 'label'], axcodes='RAS'), ScaleIntensityRanged(keys=['image'], a_min=-57, a_max=164, b_min=0.0, b_max=1.0, clip=True), RandCropByPosNegLabeld(keys=['image', 'label'], label_key='label', spatial_size=(96, 96, 96), pos=1, neg=1, num_samples=4, image_key='image', image_threshold=0), ToTensord(keys=['image', 'label'])]
首次使用时，基于文件名的原始数据将通过 [LoadImaged, Orientationd, ScaleIntensityRanged] 变换进行处理，并将结果张量写入 cache_dir，然后再应用剩余的随机依赖变换 [RandCropByPosNegLabeld, ToTensord] 元素以供分析使用。
数据集后续使用时，直接从 cache_dir 读取预处理结果，然后应用变换处理中随机依赖的部分。
训练期间调用 set_data() 更新输入数据并重新计算缓存内容。
注意
输入数据必须是文件路径列表，并将它们哈希作为缓存键。
缓存文件的文件名也尽量包含变换的哈希值。通过这种方式，PersistentDataset 应能应对变换的变化。然而，这并不能保证完全没有问题，因此在修改变换时应谨慎，以避免意外错误。如果存在疑问，建议清除缓存目录。
- 惰性重采样
如果您使用了 monai.transforms.Compose 的惰性重采样功能，请参考其文档以熟悉 PersistentDataset 与惰性重采样的交互。
- __init__(data, transform, cache_dir, hash_func=<function pickle_hashing>, pickle_module='pickle', pickle_protocol=2, hash_transform=None, reset_ops_id=True)[source]#
- 参数:
data – 输入数据文件路径，用于加载和变换以生成模型所需数据集。PersistentDataset 要求输入数据是可序列化列表，并使用 hash_func 将其哈希作为缓存键。
transform – 用于对输入数据执行操作的变换。
cache_dir – 如果指定，这是预计算变换数据张量持久化存储的位置。cache_dir 计算一次，并保留在磁盘上直到显式删除。不同的运行、程序、实验可以共享一个公共的 cache_dir，前提是变换预处理是一致的。如果 cache_dir 不存在，将自动创建。如果 cache_dir 是 None，则实际上没有缓存。
hash_func – 一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
pickle_module – 表示用于对元数据和对象进行 pickle 操作的模块的字符串，默认为 “pickle”。由于 Dataloader 的多进程中 pickle 存在限制，我们不能直接使用 pickle 作为参数，因此此处使用字符串名称代替。如果在运行时想使用其他 pickle 模块，只需注册，例如：>>> from monai.data import utils >>> utils.SUPPORTED_PICKLE_MOD[“test”] = other_pickle 此参数由 torch.save 使用，更多详细信息请查阅：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save，以及
monai.data.utils.SUPPORTED_PICKLE_MOD。pickle_protocol – 可以指定以覆盖默认协议，默认为 2。此参数由 torch.save 使用，更多详细信息请查阅：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。
hash_transform – 一个可调用对象，用于在缓存时从变换信息计算哈希值。这可以减少实验期间由于变换变化导致的错误。默认为 None（无哈希）。其他选项是 monai.data.utils 中的 pickle_hashing 和 json_hashing 函数。
reset_ops_id – 是否将 TraceKeys.ID 设置为
Tracekys.NONE，默认为True。启用此项时，跟踪的变换实例 ID 将从缓存的 MetaTensors 中移除。这在使用缓存内容和重新创建的变换实例反转应用操作时，对于跳过变换实例检查非常有用。
GDSDataset#
- class monai.data.GDSDataset(data, transform, cache_dir, device, hash_func=<function pickle_hashing>, hash_transform=None, reset_ops_id=True, **kwargs)[source]#
PersistentDataset 的扩展，使用 GPU 内存和存储之间的直接内存访问(DMA)数据路径，从而避免通过 CPU 的弹跳缓冲区。此直接路径可以提高系统带宽，同时降低 CPU 和 GPU 的延迟和利用率负载。
教程可查阅：Project-MONAI/tutorials。
另请参阅：rapidsai/kvikio
- __init__(data, transform, cache_dir, device, hash_func=<function pickle_hashing>, hash_transform=None, reset_ops_id=True, **kwargs)[source]#
- 参数:
data – 输入数据文件路径，用于加载和变换以生成模型所需数据集。GDSDataset 要求输入数据是可序列化列表，并使用 hash_func 将其哈希作为缓存键。
transform – 用于对输入数据执行操作的变换。
cache_dir – 如果指定，这是预计算变换数据张量的 GPU 直接存储位置。cache_dir 计算一次，并保留在磁盘上直到显式删除。不同的运行、程序、实验可以共享一个公共的 cache_dir，前提是变换预处理是一致的。如果 cache_dir 不存在，将自动创建。如果 cache_dir 是 None，则实际上没有缓存。
device – 用于放置输出 Tensor 数据的目标设备。请注意，只能使用 int 指定要使用的 gpu。
hash_func – 一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
hash_transform – 一个可调用对象，用于在缓存时从变换信息计算哈希值。这可以减少实验期间由于变换变化导致的错误。默认为 None（无哈希）。其他选项是 monai.data.utils 中的 pickle_hashing 和 json_hashing 函数。
reset_ops_id – 是否将 TraceKeys.ID 设置为
Tracekys.NONE，默认为True。启用此项时，跟踪的变换实例 ID 将从缓存的 MetaTensors 中移除。这在使用缓存内容和重新创建的变换实例反转应用操作时，对于跳过变换实例检查非常有用。
CacheNTransDataset#
- class monai.data.CacheNTransDataset(data, transform, cache_n_trans, cache_dir, hash_func=<function pickle_hashing>, pickle_module='pickle', pickle_protocol=2, hash_transform=None, reset_ops_id=True)[source]#
PersistentDataset 的扩展，它还可以缓存前 N 个变换的结果，无论它们是否是随机的。
- __init__(data, transform, cache_n_trans, cache_dir, hash_func=<function pickle_hashing>, pickle_module='pickle', pickle_protocol=2, hash_transform=None, reset_ops_id=True)[source]#
- 参数:
data – 输入数据文件路径，用于加载和变换以生成模型所需数据集。PersistentDataset 要求输入数据是可序列化列表，并使用 hash_func 将其哈希作为缓存键。
transform – 用于对输入数据执行操作的变换。
cache_n_trans – 缓存前 N 个变换的结果。
cache_dir – 如果指定，这是预计算变换数据张量持久化存储的位置。cache_dir 计算一次，并保留在磁盘上直到显式删除。不同的运行、程序、实验可以共享一个公共的 cache_dir，前提是变换预处理是一致的。如果 cache_dir 不存在，将自动创建。如果 cache_dir 是 None，则实际上没有缓存。
hash_func – 一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
pickle_module – 表示用于对元数据和对象进行 pickle 操作的模块的字符串，默认为 “pickle”。由于 Dataloader 的多进程中 pickle 存在限制，我们不能直接使用 pickle 作为参数，因此此处使用字符串名称代替。如果在运行时想使用其他 pickle 模块，只需注册，例如：>>> from monai.data import utils >>> utils.SUPPORTED_PICKLE_MOD[“test”] = other_pickle 此参数由 torch.save 使用，更多详细信息请查阅：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save，以及
monai.data.utils.SUPPORTED_PICKLE_MOD。pickle_protocol – 可以指定以覆盖默认协议，默认为 2。此参数由 torch.save 使用，更多详细信息请查阅：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。
hash_transform – 一个可调用对象，用于在缓存时从变换信息计算哈希值。这可以减少实验期间由于变换变化导致的错误。默认为 None（无哈希）。其他选项是 monai.data.utils 中的 pickle_hashing 和 json_hashing 函数。
reset_ops_id – 是否将 TraceKeys.ID 设置为
Tracekys.NONE，默认为True。启用此项时，跟踪的变换实例 ID 将从缓存的 MetaTensors 中移除。这在使用缓存内容和重新创建的变换实例反转应用操作时，对于跳过变换实例检查非常有用。
LMDBDataset#
- class monai.data.LMDBDataset(data, transform, cache_dir='cache', hash_func=<function pickle_hashing>, db_name='monai_cache', progress=True, pickle_protocol=5, hash_transform=None, reset_ops_id=True, lmdb_kwargs=None)[source]#
使用 LMDB 作为后端的 PersistentDataset 扩展。
示例
>>> items = [{"data": i} for i in range(5)] # [{'data': 0}, {'data': 1}, {'data': 2}, {'data': 3}, {'data': 4}] >>> lmdb_ds = monai.data.LMDBDataset(items, transform=monai.transforms.SimulateDelayd("data", delay_time=1)) >>> print(list(lmdb_ds)) # using the cached results
- __init__(data, transform, cache_dir='cache', hash_func=<function pickle_hashing>, db_name='monai_cache', progress=True, pickle_protocol=5, hash_transform=None, reset_ops_id=True, lmdb_kwargs=None)[source]#
- 参数:
data – 输入数据文件路径，用于加载和变换以生成模型所需数据集。LMDBDataset 要求输入数据是可序列化列表，并使用 hash_func 将其哈希作为缓存键。
transform – 用于对输入数据执行操作的变换。
cache_dir – 如果指定，这是预计算变换数据张量的持久化存储位置。cache_dir 计算一次，并保留在磁盘上直到显式删除。不同的运行、程序、实验可以共享一个公共的 cache_dir，前提是变换预处理是一致的。如果 cache_dir 不存在，将自动创建。默认为 “./cache”。
hash_func – 一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
db_name – lmdb 数据库文件名。默认为 “monai_cache”。
progress – 是否显示进度条。
pickle_protocol – pickle 协议版本。默认为 pickle.HIGHEST_PROTOCOL。https://docs.pythonlang.cn/3/library/pickle.html#pickle-protocols
hash_transform – 一个可调用对象，用于在缓存时从变换信息计算哈希值。这可以减少实验期间由于变换变化导致的错误。默认为 None（无哈希）。其他选项是 monai.data.utils 中的 pickle_hashing 和 json_hashing 函数。
reset_ops_id – 是否将 TraceKeys.ID 设置为
Tracekeys.NONE，默认为True。启用此项时，跟踪的变换实例 ID 将从缓存的 MetaTensors 中移除。这在使用缓存内容和重新创建的变换实例反转应用操作时，对于跳过变换实例检查非常有用。lmdb_kwargs – lmdb 环境的额外关键字参数。更多详细信息请访问：https://lmdb.readthedocs.io/en/release/#environment-class
CacheDataset#
- class monai.data.CacheDataset(data, transform=None, cache_num=9223372036854775807, cache_rate=1.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, hash_as_key=False, hash_func=<function pickle_hashing>, runtime_cache=False)[source]#
具有缓存机制的数据集，可在训练期间加载数据并缓存确定性变换的结果。
通过缓存非随机预处理变换的结果，它加速了训练数据 pipeline。如果请求的数据不在缓存中，所有变换将正常运行（另请参阅
monai.data.dataset.Dataset）。用户可以设置缓存率或要缓存的项数。建议尝试不同的 cache_num 或 cache_rate 以找到最佳训练速度。
应缓存的变换必须实现 monai.transforms.Transform 接口且不应是 Randomizable。此数据集将缓存 Compose 实例中第一个 Randomizable Transform 之前的结果。因此，为了提高缓存效率，在组合变换链时，请始终将尽可能多的非随机变换放在随机变换之前。如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
例如，如果变换是一个 Compose 实例，包含
transforms = Compose([ LoadImaged(), EnsureChannelFirstd(), Spacingd(), Orientationd(), ScaleIntensityRanged(), RandCropByPosNegLabeld(), ToTensord() ])
当 transforms 在多 epoch 训练 pipeline 中使用时，在第一个训练 epoch 之前，此数据集将缓存直到
ScaleIntensityRanged的结果，因为所有非随机变换 LoadImaged、EnsureChannelFirstd、Spacingd、Orientationd、ScaleIntensityRanged 都可以被缓存。训练期间，数据集将加载缓存结果并运行RandCropByPosNegLabeld和ToTensord，因为RandCropByPosNegLabeld是一个随机变换，其结果不会被缓存。训练期间调用 set_data() 更新输入数据并重新计算缓存内容，请注意这要求 PyTorch DataLoader 中的 persistent_workers=False。
注意
CacheDataset 在第一个 epoch 之前在主进程中执行非随机变换并准备缓存内容，然后 DataLoader 的所有子进程在训练期间将读取主进程中的相同缓存内容。根据预期缓存数据的大小，准备缓存内容可能需要很长时间。因此，在实际训练前调试或验证程序时，用户可以设置 cache_rate=0.0 或 cache_num=0 以暂时跳过缓存。
- 惰性重采样
如果您使用了 monai.transforms.Compose 的惰性重采样功能，请参考其文档以熟悉 CacheDataset 与惰性重采样的交互。
- __init__(data, transform=None, cache_num=9223372036854775807, cache_rate=1.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, hash_as_key=False, hash_func=<function pickle_hashing>, runtime_cache=False)[source]#
- 参数:
data – 输入数据，用于加载和变换以生成模型所需数据集。
transform – 用于对输入数据执行操作的变换。
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 – 如果在初始化中计算缓存，则 worker 线程数。如果 num_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，将使用 1 代替。
progress – 是否显示进度条。
copy_cache – 是否在应用随机变换之前 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容（例如，从缓存图像中随机裁剪并 deepcopy 裁剪区域），或者在 multi-processing 环境中每个缓存项仅使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy array 或 PyTorch tensor 转换为连续的。这可能有助于提高后续逻辑的性能。
hash_as_key – 是否计算输入数据的哈希值作为保存缓存的键，如果键已存在，则避免保存重复内容。这有助于在数据集有重复项或增强数据集时节省内存。
hash_func – 如果 hash_as_key 为真，则为一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
runtime_cache –
运行时缓存模式。默认为 False，在初始化期间准备整个
data的缓存内容，这可能显著增加构造函数调用到第一个 mini-batch 生成所需的时间。提供了三个选项，可在数据集初始化后即时计算缓存"threads"或True：使用常规的list存储缓存项。"processes"：使用 ListProxy 存储缓存项，可在进程间共享。类似列表的对象：用户提供的用于存储缓存项的容器。
对于基于线程的缓存（通常用于缓存 cuda 张量），推荐选项 1。对于具有多进程数据加载的单进程工作流，推荐选项 2。对于多进程工作流（通常用于分布式训练），其中此类在子进程中初始化，推荐选项 3，并且应在主进程中准备类列表对象并传递给所有子进程。不遵循这些建议可能导致运行时错误或跨进程重复缓存。
SmartCacheDataset#
- class monai.data.SmartCacheDataset(data, transform=None, replace_rate=0.1, cache_num=9223372036854775807, cache_rate=1.0, num_init_workers=1, num_replace_workers=1, progress=True, shuffle=True, seed=0, copy_cache=True, as_contiguous=True, runtime_cache=False)[source]#
重新实现了 NVIDIA Clara-train SDK 中的 SmartCache 机制。在任何时候，缓存池只保留整个数据集的一个子集。在每个 epoch 中，只有缓存中的项用于训练。这确保了训练所需的数据随时可用，保持 GPU 资源忙碌。请注意，缓存项在馈送到 GPU 之前仍可能需要经过非确定性变换序列。同时，另一个线程正在通过将变换序列应用于不在缓存中的项来准备替换项。一旦一个 epoch 完成，Smart Cache 将相同数量的项替换为准备好的替换项。Smart Cache 使用简单的滑动窗口 (running window)算法来确定缓存内容和替换项。设 N 为配置的缓存中对象数量；R 为替换对象数量 (R = ceil(N * r)，其中 r 是配置的替换率)。更多详细信息，请参考：https://docs.nvda.net.cn/clara/clara-train-archive/3.1/nvmidl/additional_features/smart_cache.html 如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
例如，如果我们有 5 张图像：[image1, image2, image3, image4, image5]，并且 cache_num=4，replace_rate=0.25。那么每个 epoch 实际缓存和替换的训练图像如下所示
epoch 1: [image1, image2, image3, image4] epoch 2: [image2, image3, image4, image5] epoch 3: [image3, image4, image5, image1] epoch 3: [image4, image5, image1, image2] epoch N: [image[N % 5] ...]
SmartCacheDataset 的使用包含 4 个步骤
初始化 SmartCacheDataset 对象并缓存第一个 epoch。
调用 start() 在后台运行替换线程。
在每个 epoch 之前调用 update_cache() 替换训练项。
训练结束时调用 shutdown()。
训练期间调用 set_data() 更新输入数据并重新计算缓存内容，请注意先调用 shutdown() 停止，然后更新数据并调用 start() 重新启动。
注意
以下情况此替换功能将不起作用： 1. 将 DataLoader 的 multiprocessing_context 设置为 spawn。 2. 使用 torch.multiprocessing.spawn 启动分布式数据并行。 3. 在 windows 上运行（默认多进程方法是 spawn）且 num_workers 大于 0。 4. 在 DataLoader 中设置 persistent_workers 为 True 且 num_workers 大于 0。
如果使用 MONAI 工作流，请将 SmartCacheHandler 添加到 trainer 的处理程序列表中，否则，请确保在训练期间调用 start()、update_cache() 和 shutdown()。
- 参数:
data – 输入数据，用于加载和变换以生成模型所需数据集。
transform – 用于对输入数据执行操作的变换。
replace_rate – 每个 epoch 中要替换的缓存项百分比（默认为 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_init_workers – 用于为第一个 epoch 初始化缓存的 worker 线程数。如果 num_init_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，将使用 1 代替。
num_replace_workers – 用于为每个 epoch 准备替换缓存的 worker 线程数。如果 num_replace_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，将使用 1 代替。
progress – 在为第一个 epoch 缓存时是否显示进度条。
shuffle – 在为第一个 epoch 准备缓存内容之前是否打乱整个数据列表。它不会就地修改原始输入数据序列。
seed – 如果 shuffle 为 True，则为随机种子，默认为 0。
copy_cache – 是否在应用随机变换之前 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容，或者在 multi-processing 环境中每个缓存项仅使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy array 或 PyTorch tensor 转换为连续的。这可能有助于提高后续逻辑的性能。
runtime_cache – 默认为 False，其他选项尚未实现。
ZipDataset#
- class monai.data.ZipDataset(datasets, transform=None)[source]#
将多个 PyTorch 数据集压缩在一起，并以元组形式一起输出数据（具有相同索引）。如果单个数据集的输出已经是元组，则将其展平并扩展到结果中。例如：如果 datasetA 返回 (img, imgmeta)，datasetB 返回 (seg, segmeta)，则最终返回 (img, imgmeta, seg, segmeta)。如果数据集长度不同，则使用它们的最小长度作为 ZipDataset 的长度。如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
示例
>>> zip_data = ZipDataset([[1, 2, 3], [4, 5]]) >>> print(len(zip_data)) 2 >>> for item in zip_data: >>> print(item) [1, 4] [2, 5]
ArrayDataset#
- class monai.data.ArrayDataset(img, img_transform=None, seg=None, seg_transform=None, labels=None, label_transform=None)[source]#
基于数组格式输入数据和变换的分割和分类任务数据集。它确保为图像、分割和标签定义的随机变换使用相同的随机种子。transform 可以是
monai.transforms.Compose或任何其他可调用对象。例如：如果基于没有元数据的 Nifti 格式图像进行训练，则所有变换都可以组合img_transform = Compose( [ LoadImage(image_only=True), EnsureChannelFirst(), RandAdjustContrast() ] ) ArrayDataset(img_file_list, img_transform=img_transform)
如果基于图像和元数据进行训练，则数组变换无法组合，因为某些变换接收多个参数或返回多个值。在这种情况下，用户需要定义自己的可调用方法来从 LoadImage 中解析元数据或将 affine 矩阵设置到 Spacing 变换中。
class TestCompose(Compose): def __call__(self, input_): img, metadata = self.transforms[0](input_) img = self.transforms[1](img) img, _, _ = self.transforms[2](img, metadata["affine"]) return self.transforms[3](img), metadata img_transform = TestCompose( [ LoadImage(image_only=False), EnsureChannelFirst(), Spacing(pixdim=(1.5, 1.5, 3.0)), RandAdjustContrast() ] ) ArrayDataset(img_file_list, img_transform=img_transform)
示例
>>> ds = ArrayDataset([1, 2, 3, 4], lambda x: x + 0.1) >>> print(ds[0]) 1.1 >>> ds = ArrayDataset(img=[1, 2, 3, 4], seg=[5, 6, 7, 8]) >>> print(ds[0]) [1, 5]
- __init__(img, img_transform=None, seg=None, seg_transform=None, labels=None, label_transform=None)[source]#
使用文件名列表初始化数据集。变换 img_transform 应用于图像，seg_transform 应用于分割。
- 参数:
img – 图像序列。
img_transform – 应用于 img 中每个元素的变换。
seg – 分割序列。
seg_transform – 应用于 seg 中每个元素的变换。
labels – 标签序列。
label_transform – 应用于 labels 中每个元素的变换。
ImageDataset#
- class monai.data.ImageDataset(image_files, seg_files=None, labels=None, transform=None, seg_transform=None, label_transform=None, image_only=True, transform_with_metadata=False, dtype=<class 'numpy.float32'>, reader=None, *args, **kwargs)[source]#
从给定的文件名列表加载图像/分割对文件。可以为图像和分割数组分别指定变换。此数据集与ArrayDataset的区别在于，此数据集可以对图像和分割应用变换链并返回图像和元数据，而且无需指定变换来从文件加载图像。有关更多信息，请参阅 MONAI 教程仓库中的 image_dataset 演示，Project-MONAI/tutorials
- __init__(image_files, seg_files=None, labels=None, transform=None, seg_transform=None, label_transform=None, image_only=True, transform_with_metadata=False, dtype=<class 'numpy.float32'>, reader=None, *args, **kwargs)[source]#
使用图像和分割文件名列表初始化数据集。transform 变换应用于图像，seg_transform 应用于分割。
- 参数:
image_files – 图像文件名列表。
seg_files – 如果是分割任务，则是分割文件名列表。
labels – 如果是分类任务，则是分类标签列表。
transform – 应用于图像数组的变换。
seg_transform – 应用于分割数组的变换。
label_transform – 应用于标签数据的变换。
image_only – 如果为 True，则仅返回图像体，否则返回图像体和元数据。
transform_with_metadata – 如果为 True，则元数据将尽可能传递给变换。
dtype – 如果不为 None，则将加载的图像转换为此数据类型。
reader – 注册用于加载图像文件和元数据的读取器，如果为 None，将使用默认读取器。如果提供字符串的读取器名称，则将使用*args和**kwargs参数构造一个读取器对象，支持的读取器名称包括：“NibabelReader”、“PILReader”、“ITKReader”、“NumpyReader”
args – 如果提供了读取器名称，则为读取器提供额外参数。
kwargs – 如果提供了读取器名称，则为读取器提供额外参数。
- 抛出:
ValueError – 当
seg_files的长度与image_files的长度不同时。
NPZDictItemDataset#
- class monai.data.NPZDictItemDataset(npzfile, keys, transform=None, other_keys=())[source]#
表示从已加载的 NPZ 文件创建的数据集。要加载的文件成员在keys的键中命名，并存储在对应的键名下。所有加载的数组必须具有相同的 0 维（批次）大小。项目始终是字典，将名称映射到从加载的数组中提取的项目。如果传递切片索引，将返回一个 PyTorch Subset，例如：data: Subset = dataset[1:4]，有关更多详细信息，请参阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.Subset
- 参数:
npzfile – .npz 文件的路径或包含 .npz 文件数据的流。
keys – 将要从文件加载的键映射到数据集中存储的名称。
transform – 应用于批次字典的变换。
other_keys – 要从文件加载并存储在字典other_keys中的辅助数据，不通过 __getitem__ 返回。
CSVDataset#
- class monai.data.CSVDataset(src=None, row_indices=None, col_names=None, col_types=None, col_groups=None, transform=None, kwargs_read_csv=None, **kwargs)[source]#
用于从 CSV 文件加载数据并生成字典列表的数据集，每个字典映射到 CSV 文件的一行，字典的键映射到 CSV 文件的列名。
它可以加载多个 CSV 文件并通过附加的kwargs参数连接表格。支持仅加载特定行和列。它还可以将加载的几列分组以生成新列，例如，设置col_groups={“meta”: [“meta_0”, “meta_1”, “meta_2”]}，输出可以是
[ {"image": "./image0.nii", "meta_0": 11, "meta_1": 12, "meta_2": 13, "meta": [11, 12, 13]}, {"image": "./image1.nii", "meta_0": 21, "meta_1": 22, "meta_2": 23, "meta": [21, 22, 23]}, ]
- 参数:
src – 如果提供 CSV 文件的文件名，可以是 str、URL、路径对象或类文件对象来加载。也支持直接提供 pandasDataFrame，将跳过从文件名加载。如果提供文件名列表或 pandasDataFrame，将连接表格。
row_indices – 要加载的预期行的索引。它应该是一个列表，每个项目可以是整数或表示范围[start, end)的列表。例如：row_indices=[[0, 100], 200, 201, 202, 300]。如果为 None，则加载文件中的所有行。
col_names – 要加载的预期列名。如果为 None，则加载所有列。
col_types –
用于转换已加载列的 type 和 default value，如果为 None，则使用原始数据。它应该是一个字典，每个项映射到预期列，key 是列名，value 是 None 或一个定义默认值和数据类型的字典。字典中支持的键包括：[“type”, “default”]。例如
col_types = { "subject_id": {"type": str}, "label": {"type": int, "default": 0}, "ehr_0": {"type": float, "default": 0.0}, "ehr_1": {"type": float, "default": 0.0}, "image": {"type": str, "default": None}, }
col_groups – 用于将加载的列分组生成新列的参数，它应该是一个字典，每个项映射到一个组，key 将是新列名，value 是要组合的列名。例如：col_groups={“ehr”: [f”ehr_{i}” for i in range(10)], “meta”: [“meta_1”, “meta_2”]}
transform – 应用于加载的字典数据项的变换。
kwargs_read_csv – 传递给 pandasread_csv函数的字典参数。
kwargs – 用于 pandas.merge() API 连接表格的额外参数。
基于补丁的数据集#
GridPatchDataset#
- class monai.data.GridPatchDataset(data, patch_iter, transform=None, with_coordinates=True, cache=False, cache_num=9223372036854775807, cache_rate=1.0, num_workers=1, progress=True, copy_cache=True, as_contiguous=True, hash_func=<function pickle_hashing>)[source]#
从图像数据集中读取数据并生成补丁。通常与PatchIter或PatchIterd一起使用，以便补丁按连续的网格采样方案选择。
import numpy as np from monai.data import GridPatchDataset, DataLoader, PatchIter, RandShiftIntensity # image-level dataset images = [np.arange(16, dtype=float).reshape(1, 4, 4), np.arange(16, dtype=float).reshape(1, 4, 4)] # image-level patch generator, "grid sampling" patch_iter = PatchIter(patch_size=(2, 2), start_pos=(0, 0)) # patch-level intensity shifts patch_intensity = RandShiftIntensity(offsets=1.0, prob=1.0) # construct the dataset ds = GridPatchDataset(data=images, patch_iter=patch_iter, transform=patch_intensity) # use the grid patch dataset for item in DataLoader(ds, batch_size=2, num_workers=2): print("patch size:", item[0].shape) print("coordinates:", item[1]) # >>> patch size: torch.Size([2, 1, 2, 2]) # coordinates: tensor([[[0, 1], [0, 2], [0, 2]], # [[0, 1], [2, 4], [0, 2]]])
- 参数:
data – 用于读取图像数据的数据源。
patch_iter – 将输入图像（数据集中的一项）转换为图像补丁的可迭代对象。patch_iter(dataset[idx])必须生成一个元组：(补丁, 坐标)。另请参阅：
monai.data.PatchIter或monai.data.PatchIterd。transform – 应用于补丁的可调用数据变换。
with_coordinates – 是否生成每个补丁的坐标，默认为True。
cache – 是否使用缓存机制，默认为False。另请参阅：
monai.data.CacheDataset。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 – 如果在初始化中计算缓存，则 worker 线程数。如果 num_workers 为 None，则使用 os.cpu_count() 返回的数量。如果指定的值小于 1，将使用 1 代替。
progress – 是否显示进度条。
copy_cache – 是否在应用随机变换之前 deepcopy 缓存内容，默认为 True。如果随机变换不修改缓存内容（例如，从缓存图像中随机裁剪并 deepcopy 裁剪区域），或者在 multi-processing 环境中每个缓存项仅使用一次，可以设置 copy=False 以获得更好的性能。
as_contiguous – 是否将缓存的 NumPy array 或 PyTorch tensor 转换为连续的。这可能有助于提高后续逻辑的性能。
hash_func – 一个可调用对象，用于计算要缓存的数据项的哈希值。默认为 monai.data.utils.pickle_hashing。
PatchDataset#
- class monai.data.PatchDataset(data, patch_func, samples_per_image=1, transform=None)[source]#
从图像数据集中读取数据并生成补丁。补丁由用户指定的 callable patch_func 生成，并可选地由transform进行后处理。例如，从图像数据集中生成随机补丁样本：
import numpy as np from monai.data import PatchDataset, DataLoader from monai.transforms import RandSpatialCropSamples, RandShiftIntensity # image dataset images = [np.arange(16, dtype=float).reshape(1, 4, 4), np.arange(16, dtype=float).reshape(1, 4, 4)] # image patch sampler n_samples = 5 sampler = RandSpatialCropSamples(roi_size=(3, 3), num_samples=n_samples, random_center=True, random_size=False) # patch-level intensity shifts patch_intensity = RandShiftIntensity(offsets=1.0, prob=1.0) # construct the patch dataset ds = PatchDataset(dataset=images, patch_func=sampler, samples_per_image=n_samples, transform=patch_intensity) # use the patch dataset, length: len(images) x samplers_per_image print(len(ds)) >>> 10 for item in DataLoader(ds, batch_size=2, shuffle=True, num_workers=2): print(item.shape) >>> torch.Size([2, 1, 3, 3])
PatchIter#
- class monai.data.PatchIter(patch_size, start_pos=(), mode=wrap, **pad_opts)[source]#
返回具有预定义属性（如patch_size）的补丁生成器。通常与
monai.data.GridPatchDataset一起使用。- __call__(array)[source]#
- 参数:
array (~NdarrayTensor) – 要从中生成补丁的图像。
- 返回类型:
Generator[tuple[~NdarrayTensor,ndarray],None,None]
- __init__(patch_size, start_pos=(), mode=wrap, **pad_opts)[source]#
- 参数:
patch_size – 要生成切片的补丁大小，0/None 选择整个维度。
start_pos – 数组中的起始位置，默认每个维度为 0。
mode – 可用模式：（Numpy）{
"constant","edge","linear_ramp","maximum","mean","median","minimum","reflect","symmetric","wrap","empty"}（PyTorch）{"constant","reflect","replicate","circular"}。列表中的字符串值之一或用户提供的函数。如果为 None，则不执行填充。默认为"wrap"。另请参阅：https://numpy.com.cn/doc/stable/reference/generated/numpy.pad.html https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html 需要 pytorch >= 1.10 获得最佳兼容性。pad_opts – np.pad函数的其他参数。请注意，np.pad将通道维度视为第一个维度。
注意
patch_size是要从输入数组中采样的补丁大小。假设数组的第一个维度是通道维度，它将完整生成，因此不应在patch_size中指定。例如，对于大小为 (1, 20, 20, 20) 的单通道 3D 数组，要进行规则网格采样以获得八个补丁 (1, 10, 10, 10)，应指定patch_size为 (10, 10, 10)。
PatchIterd#
- class monai.data.PatchIterd(keys, patch_size, start_pos=(), mode=wrap, **pad_opts)[source]#
基于字典的
monai.data.PatchIter包装器。为字典数据和坐标返回一个补丁生成器，通常与monai.data.GridPatchDataset一起使用。假定keys指定的所有预期字段具有相同的形状。- 参数:
keys – 要迭代补丁的相应项目的键。
patch_size – 要生成切片的补丁大小，0/None 选择整个维度。
start_pos – 数组中的起始位置，默认每个维度为 0。
mode – 可用模式：（Numpy）{
"constant","edge","linear_ramp","maximum","mean","median","minimum","reflect","symmetric","wrap","empty"}（PyTorch）{"constant","reflect","replicate","circular"}。列表中的字符串值之一或用户提供的函数。如果为 None，则不执行填充。默认为"wrap"。另请参阅：https://numpy.com.cn/doc/stable/reference/generated/numpy.pad.html https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html 需要 pytorch >= 1.10 获得最佳兼容性。pad_opts – np.pad函数的其他参数。请注意，np.pad将通道维度视为第一个维度。
图像读取器#
ImageReader#
- class monai.data.ImageReader[source]#
定义加载图像文件 API 的抽象类。
此类实现的典型用法是：
image_reader = MyImageReader() img_obj = image_reader.read(path_to_image) img_data, meta_data = image_reader.get_data(img_obj)
read调用将图像文件名转换为图像对象。
get_data调用获取图像数据和元数据。
读取器应实现verify_suffix，其中包含按文件名扩展名检查输入文件名的逻辑。
- abstract get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数必须返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。
- 参数:
img – 从图像文件加载的图像对象或图像对象列表。
- 返回类型:
tuple[ndarray,dict]
ITKReader#
- class monai.data.ITKReader(channel_dim=None, series_name='', reverse_indexing=False, series_meta=False, affine_lps_to_ras=True, **kwargs)[source]#
基于 ITK 库加载医学图像。所有支持的图像格式可在以下位置找到：InsightSoftwareConsortium/ITK 加载的数据数组将采用 C 序，例如，3D 图像 NumPy 数组索引顺序将是CDWH。
- 参数:
channel_dim –
输入图像的通道维度，默认为 None。这用于在元数据中设置 original_channel_dim，EnsureChannelFirstD 读取此字段。如果为 None，则original_channel_dim将为no_channel或-1。
Nifti 文件通常是“通道在后”，因此无需指定此参数。
PNG 文件通常GetNumberOfComponentsPerPixel()==3，因此无需指定此参数。
series_name – 如果有多个 DICOM 系列，则为 DICOM 系列的名称。加载 DICOM 系列时使用。
reverse_indexing – 是否对返回的数据数组使用反向空间索引约定。如果为
False，则空间索引约定将反转以与 ITK 兼容；否则，空间索引遵循 numpy 约定。默认为False。此选项不影响元数据。series_meta – 是否加载 DICOM 系列的元数据（使用第一个切片的元数据）。此标志仅在加载 DICOM 系列时检查。默认为
False。affine_lps_to_ras – 是否将仿射矩阵从“LPS”转换为“RAS”。默认为
True。设置为True以与NibabelReader保持一致，否则仿射矩阵保持 ITK 约定。kwargs – itk.imread API 的其他参数。有关可用参数的更多详细信息：InsightSoftwareConsortium/ITK
- get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。它构建affine、original_affine和spatial_shape并将其存储在元数据字典中。加载文件列表时，它们会作为第一个维度堆叠到一个新维度，并使用第一个图像的元数据来表示输出元数据。
- 参数:
img – 从图像文件加载的 ITK 图像对象或 ITK 图像对象列表。
- 返回类型:
tuple[ndarray,dict]
- read(data, **kwargs)[source]#
从指定文件或文件读取图像数据，它可以读取图像列表并在get_data()中将它们堆叠为多通道数据。如果传递目录路径而不是文件路径，则将其视为 DICOM 图像系列并读取。请注意，返回的对象是 ITK 图像对象或 ITK 图像对象列表。
- 参数:
data – 要读取的文件名或文件名列表。
kwargs – itk.imread API 的其他参数，将覆盖self.kwargs中现有键的值。有关可用参数的更多详细信息：InsightSoftwareConsortium/ITK
NibabelReader#
- class monai.data.NibabelReader(channel_dim=None, as_closest_canonical=False, squeeze_non_spatial_dims=False, **kwargs)[source]#
基于 Nibabel 库加载 NIfTI 格式图像。
- 参数:
as_closest_canonical – 如果为 True，则加载图像为最接近规范轴格式。
squeeze_non_spatial_dims – 如果为 True，则非空间单例将被压缩，例如 (256,256,1,3) -> (256,256,3)。
channel_dim – 输入图像的通道维度，默认为 None。这用于在元数据中设置 original_channel_dim，EnsureChannelFirstD 读取此字段。如果为 None，original_channel_dim将为no_channel或-1。大多数 Nifti 文件通常是“通道在后”，无需为它们指定此参数。
kwargs – nibabel.load API 的其他参数。有关可用参数的更多详细信息：nipy/nibabel
- get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。它构建affine、original_affine和spatial_shape并将其存储在元数据字典中。加载文件列表时，它们会作为第一个维度堆叠到一个新维度，并使用第一个图像的元数据来呈现输出元数据。
- 参数:
img – 从图像文件加载的 Nibabel 图像对象或 Nibabel 图像对象列表。
- 返回类型:
tuple[ndarray,dict]
- read(data, **kwargs)[source]#
从指定文件或文件读取图像数据，它可以读取图像列表并在get_data()中将它们堆叠为多通道数据。请注意，返回的对象是 Nibabel 图像对象或 Nibabel 图像对象列表。
- 参数:
data – 要读取的文件名或文件名列表。
kwargs – nibabel.load API 的其他参数，将覆盖self.kwargs中现有键的值。有关可用参数的更多详细信息：nipy/nibabel
NumpyReader#
- class monai.data.NumpyReader(npz_keys=None, channel_dim=None, **kwargs)[source]#
基于 Numpy 库加载 NPY 或 NPZ 格式数据，它们可以是数组或 pickled 对象。典型用法是加载分类任务的mask数据。它可以使用指定的npz_keys加载部分 npz 文件。
- 参数:
npz_keys – 如果加载 npz 文件，仅加载指定的键，如果为 None，加载所有项目。将加载的项目堆叠在一起以构建新的第一个维度。
channel_dim – 如果不为 None，则明确指定通道维度，否则，将数组视为没有通道。
kwargs – numpy.load API 的其他参数，除了allow_pickle。有关可用参数的更多详细信息：https://numpy.com.cn/doc/stable/reference/generated/numpy.load.html
- get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。它构建affine、original_affine和spatial_shape并将其存储在元数据字典中。加载文件列表时，它们会作为第一个维度堆叠到一个新维度，并使用第一个图像的元数据来表示输出元数据。
- 参数:
img – 从文件加载的 Numpy 数组或 Numpy 数组列表。
- 返回类型:
tuple[ndarray,dict]
- read(data, **kwargs)[source]#
从指定文件或文件读取图像数据，它可以读取数据文件列表并在get_data()中将它们堆叠为多通道数据。请注意，返回的对象是 Numpy 数组或 Numpy 数组列表。
- 参数:
data – 要读取的文件名或文件名列表。
kwargs – numpy.load API 的其他参数，除了allow_pickle，将覆盖self.kwargs中现有键的值。有关可用参数的更多详细信息：https://numpy.com.cn/doc/stable/reference/generated/numpy.load.html
PILReader#
- class monai.data.PILReader(converter=None, reverse_indexing=True, **kwargs)[source]#
从提供的路径加载常见 2D 图像格式（支持 PNG、JPG、BMP）文件或文件列表。
- 参数:
converter – read()后用于转换图像数据的附加函数。例如，使用converter=lambda image: image.convert(“LA”)来转换图像格式。
reverse_indexing – 加载数组后是否交换轴 0 和 1，默认启用此选项，以便读取器的输出与其他读取器保持一致。将此选项设置为
False以使用 PIL 后端的原始空间轴约定。kwargs – read()中Image.open API 的其他参数，有关可用参数的更多详细信息：https://pillow.pythonlang.cn/en/stable/reference/Image.html#PIL.Image.open
- get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。它计算spatial_shape并将其存储在元数据字典中。加载文件列表时，它们会作为第一个维度堆叠到一个新维度，并使用第一个图像的元数据来表示输出元数据。请注意，默认情况下self.reverse_indexing设置为
True，这会在加载数组后交换轴 0 和 1，因为 PIL 中的空间轴定义与其他常见的医学包不同。- 参数:
img – 从文件加载的 PIL Image 对象或 PIL Image 对象列表。
- 返回类型:
tuple[ndarray,dict]
- read(data, **kwargs)[source]#
从指定文件或文件读取图像数据，它可以读取图像列表并在get_data()中将它们堆叠为多通道数据。请注意，返回的对象是 PIL 图像或 PIL 图像列表。
- 参数:
data – 要读取的文件名或文件名列表。
kwargs – read()中Image.open API 的其他参数，将覆盖self.kwargs中现有键的值。有关可用参数的更多详细信息：https://pillow.pythonlang.cn/en/stable/reference/Image.html#PIL.Image.open
NrrdReader#
- class monai.data.NrrdReader(channel_dim=None, dtype=<class 'numpy.float32'>, index_order='F', affine_lps_to_ras=True, **kwargs)[source]#
基于 pynrrd 库加载 NRRD 格式图像。
- 参数:
channel_dim – 输入图像的通道维度，默认为 None。这用于在元数据中设置 original_channel_dim，EnsureChannelFirstD 读取此字段。如果为 None，original_channel_dim将为no_channel或0。NRRD 文件通常是“通道在先”。
dtype – 加载图像时数据数组的数据类型。
index_order – 指定返回的数据数组应采用 C 序（'C'）还是 Fortran 序（'F'）。Numpy 通常采用 C 序，但 NRRD 头部的默认值为 F。
affine_lps_to_ras – 是否将仿射矩阵从“LPS”转换为“RAS”。默认为
True。设置为True以与NibabelReader保持一致，否则仿射矩阵不做修改。kwargs – nrrd.read API 的其他参数。有关可用参数的更多详细信息：mhe/pynrrd
- get_data(img)[source]#
从加载的图像中提取数据数组和元数据并返回它们。此函数必须返回两个对象，第一个是图像数据的 numpy 数组，第二个是元数据的字典。
- 参数:
img – 从图像文件加载的NrrdImage或图像对象列表。
图像写入器#
resolve_writer#
register_writer#
- monai.data.register_writer(ext_name, *im_writers)[source]#
注册
ImageWriter，以便写入文件名扩展名为ext_name的文件时，可以解析为潜在合适的ImageWriter元组。可以注册自定义写入器：from monai.data import register_writer # `MyWriter` must implement `ImageWriter` interface register_writer("nii", MyWriter)
- 参数:
ext_name – 图像的文件名扩展名。作为索引键，它将被转换为小写字符串。
im_writers – 一个或多个 ImageWriter 类，高优先级类在前。
ImageWriter#
- class monai.data.ImageWriter(**kwargs)[source]#
此类是用于将图像写入磁盘的实用程序集合。
需要考虑的主要方面有：
- 数据数组的维度、空间维度和通道/时间维度的排列。
convert_to_channel_last()
- 当前仿射和输出仿射的元数据，数据数组应相应转换。
get_meta_info()resample_if_needed()
输出图像的数据类型处理（作为
resample_if_needed()的一部分）。
此类子类应实现后端特定函数：
set_data_array()设置数据数组（输入必须是 numpy 数组或 torch 张量）。此方法设置后端对象的数据部分。
set_metadata()设置元数据和输出仿射。此方法设置元数据，包括仿射处理和图像重采样。
后端特定数据对象
create_backend_obj()后端特定写入函数
write()
ImageWriter子类的主要用法是：writer = MyWriter() # subclass of ImageWriter writer.set_data_array(data_array) writer.set_metadata(meta_dict) writer.write(filename)
这根据
data_array和meta_dict创建一个图像写入器对象并写入到filename。它支持最多三个空间维度（重采样步骤支持 2D 和 3D）。保存多个时间步或多个通道data_array时，时间和/或模态轴应位于channel_dim。例如，一个 2D 八分类且
channel_dim=0的分割概率的形状可以是(8, 64, 64)；在这种情况下，data_array将被转换为(64, 64, 1, 8)（第三个维度保留为空间维度）。metadata可以可选地包含以下键：'original_affine'：用于数据原始仿射，它将是输出对象的仿射，默认为单位矩阵。
'affine'：应指定当前数据仿射，默认为单位矩阵。'spatial_shape'：用于数据输出空间形状。
指定
metadata时，保存器可能会将数据从“affine”定义的空间重采样到“original_affine”定义的空间，更多详细信息请参阅resample_if_needed方法。- __init__(**kwargs)[source]#
构造函数支持添加新的实例成员。基类中的当前成员是
self.data_obj，子类可以添加更多成员，以便必要的元信息可以存储在对象中并在类方法之间共享。
- classmethod convert_to_channel_last(data, channel_dim=0, squeeze_end_dims=True, spatial_ndim=3, contiguous=False)[source]#
重新排列数据数组轴，将channel_dim维移到最后，并确保有
spatial_ndim个空间维度。当
squeeze_end_dims为True时，将应用后处理步骤以移除任何末尾的单例维度。- 参数:
data – 要转换为“通道在后”格式的输入数据。
channel_dim – 指定要移到最后的数据数组的通道轴。
None表示没有通道维度，将添加一个新轴作为通道维度。整数序列表示多个非空间维度。squeeze_end_dims – 如果为
True，则移除任何末尾的单例维度（在通道移到末尾之后）。因此，如果输入为(H,W,D,C)且 C==1，则将保存为(H,W,D)。如果 D 也为 1，则将保存为(H,W)。如果为False，图像将始终保存为(H,W,D,C)。spatial_ndim – 如果需要，修改空间维度，以便输出至少具有此数量的空间维度。如果为
None，输出将具有与输入相同的空间维度数量。contiguous – 如果为
True，输出将是连续的。
- classmethod create_backend_obj(data_array, **kwargs)[source]#
子类应实现此方法以返回后端特定的数据表示对象。此方法由
cls.write使用，输入data_array假定为“通道在后”。- 返回类型:
ndarray
- classmethod get_meta_info(metadata=None)[source]#
从元数据对象中提取相关的元信息（使用
.get）。可选键为"spatial_shape"、MetaKeys.AFFINE、"original_affine"。
- classmethod resample_if_needed(data_array, affine=None, target_affine=None, output_spatial_shape=None, mode=bilinear, padding_mode=border, align_corners=False, dtype=<class 'numpy.float64'>)[source]#
将
data_array转换为target_affine指定的坐标系，其当前坐标定义由affine确定。如果
affine和target_affine之间的变换可以通过简单地转置和翻转data_array来实现，则不会发生重采样。否则，此函数将使用从affine和target_affine计算出的变换对data_array进行重采样。此函数假定 NIfTI 维度表示法。在空间上最多支持三个维度，即 1D、2D、3D 分别对应 H、HW、HWD。保存多个时间步或多个通道时，时间轴和/或模态轴应附加在前三个维度之后。例如，要保存的 2D 八分类分割概率的形状可能是(64, 64, 1, 8)。此外，形状为(64, 64, 8)或(64, 64, 8, 1)的数据将被视为单通道 3D 图像。
convert_to_channel_last方法可用于将数据转换为此处描述的格式。请注意，重采样的
data_array形状可能会有一些舍入误差。例如，将 20x20 像素的图像从像素大小 (1.5, 1.5)-mm 重采样到 (3.0, 3.0)-mm 空间将返回一个 10x10 像素的图像。但是，将 20x20 像素的图像从像素大小 (2.0, 2.0)-mm 重采样到 (3.0, 3.0)-mm 空间将输出一个 14x14 像素的图像，其中图像形状是从 13.333x13.333 像素四舍五入而来的。在这种情况下，可以指定output_spatial_shape，以便此函数将图像数据写入指定形状。- 参数:
data_array – 要转换的输入数据数组。
affine –
data_array的当前仿射。默认为单位矩阵。target_affine –
data_array的指定仿射。实际输出仿射可能因精度变化而与此值不同。output_spatial_shape – 输出图像的空间形状。此选项在需要重采样时使用。
mode – 可用选项包括 {
"bilinear","nearest","bicubic"}。此选项在需要重采样时使用。用于计算输出值的插值模式。默认为"bilinear"。另请参阅：https://pytorch.ac.cn/docs/stable/nn.functional.html#grid-samplepadding_mode – 可用选项包括 {
"zeros","border","reflection"}。此选项在需要重采样时使用。网格外部值的填充模式。默认为"border"。另请参阅：https://pytorch.ac.cn/docs/stable/nn.functional.html#grid-samplealign_corners –
grid_sample的布尔选项，用于处理角点约定。另请参阅：https://pytorch.ac.cn/docs/stable/nn.functional.html#grid-sampledtype – 重采样计算的数据类型。默认为
np.float64以获得最佳精度。如果为None，则使用输入数据的数据类型。此方法的输出数据类型始终为np.float32。
ITKWriter#
- class monai.data.ITKWriter(output_dtype=<class 'numpy.float32'>, affine_lps_to_ras=True, **kwargs)[source]#
使用 ITK-python 将数据和元数据写入磁盘文件。
import numpy as np from monai.data import ITKWriter np_data = np.arange(48).reshape(3, 4, 4) # write as 3d spatial image no channel writer = ITKWriter(output_dtype=np.float32) writer.set_data_array(np_data, channel_dim=None) # optionally set metadata affine writer.set_metadata({"affine": np.eye(4), "original_affine": -1 * np.eye(4)}) writer.write("test1.nii.gz") # write as 2d image, channel-first writer = ITKWriter(output_dtype=np.uint8) writer.set_data_array(np_data, channel_dim=0) writer.set_metadata({"spatial_shape": (5, 5)}) writer.write("test1.png")
- __init__(output_dtype=<class 'numpy.float32'>, affine_lps_to_ras=True, **kwargs)[source]#
- 参数:
output_dtype – 输出数据类型。
affine_lps_to_ras – 是否将仿射矩阵从“LPS”转换为“RAS”。默认为
True。设置为True以与NibabelWriter保持一致，否则假定仿射矩阵已采用 ITK 约定。设置为None以使用data_array.meta[MetaKeys.SPACE]来确定标志。kwargs – 传递给
ImageWriter的关键字参数。
构造函数将在内部创建
self.output_dtype。affine和channel_dim初始化为实例成员（默认None，0）。用户指定的
affine应在set_metadata中设置，用户指定的
channel_dim应在set_data_array中设置。
- classmethod create_backend_obj(data_array, channel_dim=0, affine=None, dtype=<class 'numpy.float32'>, affine_lps_to_ras=True, **kwargs)[source]#
从
data_array创建 ITK 对象。此方法假定data_array为“通道在后”。- 参数:
data_array – 输入数据数组。
channel_dim – 数据数组的通道维度。如果不是
None，则用于创建向量图像。affine – 数据数组的仿射矩阵。用于计算spacing、direction和origin。
dtype – 输出数据类型。
affine_lps_to_ras – 是否将仿射矩阵从“LPS”转换为“RAS”。默认为
True。设置为True以与NibabelWriter保持一致，否则假定仿射矩阵已采用 ITK 约定。设置为None以使用data_array.meta[MetaKeys.SPACE]来确定标志。kwargs – 关键字参数。当前的 itk.GetImageFromArray 将从此字典中读取
ttype。
- set_data_array(data_array, channel_dim=0, squeeze_end_dims=True, **kwargs)[source]#
将
data_array转换为“通道在后”（channel-last）的 numpy ndarray。- 参数:
data_array – 输入数据数组，其通道维度由
channel_dim指定。channel_dim – 数据数组的通道维度。默认为 0。
None表示数据不含任何通道维度。squeeze_end_dims – 如果为
True，则会移除所有末尾的单例维度。kwargs – 传递给
self.convert_to_channel_last的关键字参数，当前支持spatial_ndim和contiguous，默认值分别为3和False。
- set_metadata(meta_dict=None, resample=True, **options)[source]#
如需要，对
self.dataobj进行重采样。此方法假定self.data_obj是“通道在后”（channel-last）的 ndarray。- 参数:
meta_dict – 包含仿射（affine）、原始仿射和空间形状信息的元数据字典。可选键包括
"spatial_shape"、"affine"、"original_affine"。resample – 如果为
True，数据将根据原始仿射（在meta_dict中指定）进行重采样。options – 传递给
self.resample_if_needed的关键字参数，当前支持mode、padding_mode、align_corners和dtype，默认值分别为bilinear、border、False和np.float64。
NibabelWriter#
- class monai.data.NibabelWriter(output_dtype=<class 'numpy.float32'>, **kwargs)[source]#
使用 Nibabel 将数据和元数据写入磁盘文件。
import numpy as np from monai.data import NibabelWriter np_data = np.arange(48).reshape(3, 4, 4) writer = NibabelWriter() writer.set_data_array(np_data, channel_dim=None) writer.set_metadata({"affine": np.eye(4), "original_affine": np.eye(4)}) writer.write("test1.nii.gz", verbose=True)
- __init__(output_dtype=<class 'numpy.float32'>, **kwargs)[source]#
- 参数:
output_dtype (
Union[dtype,type,str,None]) – 输出数据类型。kwargs – 传递给
ImageWriter的关键字参数。
构造函数将在内部创建
self.output_dtype。affine初始化为实例成员（默认为None），用户指定的affine应在set_metadata中设置。
- classmethod create_backend_obj(data_array, affine=None, dtype=None, **kwargs)[source]#
从
data_array创建一个 Nifti1Image 对象。此方法假定data_array为“通道在后”（channel-last）格式。- 参数:
data_array – 输入数据数组。
affine – 数据数组的仿射矩阵。
dtype – 输出数据类型。
kwargs – 关键字参数。当前的
nib.nifti1.Nifti1Image将从此字典中读取header、extra、file_map。
- set_data_array(data_array, channel_dim=0, squeeze_end_dims=True, **kwargs)[source]#
将
data_array转换为“通道在后”（channel-last）的 numpy ndarray。- 参数:
data_array – 输入数据数组，其通道维度由
channel_dim指定。channel_dim – 数据数组的通道维度。默认为 0。
None表示数据不含任何通道维度。squeeze_end_dims – 如果为
True，则会移除所有末尾的单例维度。kwargs – 传递给
self.convert_to_channel_last的关键字参数，当前支持spatial_ndim，默认值为3。
- set_metadata(meta_dict, resample=True, **options)[source]#
如需要，对
self.dataobj进行重采样。此方法假定self.data_obj是“通道在后”（channel-last）的 ndarray。- 参数:
meta_dict – 包含仿射（affine）、原始仿射和空间形状信息的元数据字典。可选键包括
"spatial_shape"、"affine"、"original_affine"。resample – 如果为
True，数据将根据原始仿射（在meta_dict中指定）进行重采样。options – 传递给
self.resample_if_needed的关键字参数，当前支持mode、padding_mode、align_corners和dtype，默认值分别为bilinear、border、False和np.float64。
PILWriter#
- class monai.data.PILWriter(output_dtype=<class 'numpy.float32'>, channel_dim=0, scale=255, **kwargs)[source]#
使用 pillow 将图像数据写入磁盘文件。
它基于 PIL 库中的 Image 模块：https://pillow.pythonlang.cn/en/stable/reference/Image.html
import numpy as np from monai.data import PILWriter np_data = np.arange(48).reshape(3, 4, 4) writer = PILWriter(np.uint8) writer.set_data_array(np_data, channel_dim=0) writer.write("test1.png", verbose=True)
- __init__(output_dtype=<class 'numpy.float32'>, channel_dim=0, scale=255, **kwargs)[source]#
- 参数:
output_dtype – 输出数据类型。
channel_dim – 数据数组的通道维度。默认为 0。
None表示数据不含任何通道维度。scale – {
255,65535} 对数据进行后处理，将其裁剪到 [0, 1] 范围并缩放到 [0, 255] (uint8) 或 [0, 65535] (uint16)。默认为 None 以禁用缩放。kwargs – 传递给
ImageWriter的关键字参数。
- classmethod create_backend_obj(data_array, dtype=None, scale=255, reverse_indexing=True, **kwargs)[source]#
从
data_array创建一个 PIL 对象。- 参数:
data_array – 输入数据数组。
dtype – 输出数据类型。
scale – {
255,65535} 对数据进行后处理，将其裁剪到 [0, 1] 范围并缩放到 [0, 255] (uint8) 或 [0, 65535] (uint16)。默认为 None 以禁用缩放。reverse_indexing – 如果为
True，数据数组的前两个维度将进行交换。kwargs – 关键字参数。当前的
PILImage.fromarray将从此字典中读取image_mode，默认为None。
- classmethod get_meta_info(metadata=None)[source]#
从元数据对象中提取相关的元信息（使用
.get）。可选键为"spatial_shape"、MetaKeys.AFFINE、"original_affine"。
- classmethod resample_and_clip(data_array, output_spatial_shape=None, mode=bicubic)[source]#
如需要，将
data_array重采样到output_spatial_shape。:param data_array: 输入数据数组。此方法假定为“通道在后”（channel-last）格式。:param output_spatial_shape: 输出空间形状。:param mode: 插值模式，默认为InterpolateMode.BICUBIC。
- set_data_array(data_array, channel_dim=0, squeeze_end_dims=True, contiguous=False, **kwargs)[source]#
将
data_array转换为“通道在后”（channel-last）的 numpy ndarray。- 参数:
data_array – 输入数据数组，其通道维度由
channel_dim指定。channel_dim – 数据数组的通道维度。默认为 0。
None表示数据不含任何通道维度。squeeze_end_dims – 如果为
True，则会移除所有末尾的单例维度。contiguous – 如果为
True，数据数组将转换为连续数组。默认为False。kwargs – 传递给
self.convert_to_channel_last的关键字参数，当前支持spatial_ndim，默认值为2。
- set_metadata(meta_dict=None, resample=True, **options)[source]#
如需要，对
self.dataobj进行重采样。此方法假定self.data_obj是“通道在后”（channel-last）的 ndarray。- 参数:
meta_dict – 包含仿射、原始仿射和空间形状信息的元数据字典。可选键为
"spatial_shape"。resample – 如果为
True，数据将根据meta_dict中指定的空间形状进行重采样。options – 传递给
self.resample_if_needed的关键字参数，当前支持mode，默认值为bicubic。
- write(filename, verbose=False, **kwargs)[source]#
从
self.create_backend_obj(self.obj, ...)创建一个 PIL 图像对象，并调用save。- 参数:
filename (
Union[str,PathLike]) – 文件名或 PathLike 对象。verbose (
bool) – 如果为True，则记录进度。kwargs – 传递给
self.create_backend_obj的可选关键字参数，当前支持reverse_indexing、image_mode，默认值分别为True和None。
合成数据#
- monai.data.synthetic.create_test_image_2d(height, width, num_objs=12, rad_max=30, rad_min=5, noise_max=0.0, num_seg_classes=5, channel_dim=None, random_state=None)[source]#
返回一个包含 num_objs 个圆的嘈杂 2D 图像和一个 2D 掩码图像。圆的最大和最小半径分别为 rad_max 和 rad_min。掩码将包含 num_seg_classes 个分割类别，从 1 开始顺序标记，外加一个表示为 0 的背景类别。如果 noise_max 大于 0，则会从范围 [0, noise_max) 的均匀分布中提取噪声添加到图像中。如果 channel_dim 为 None，将创建一个不带通道维度的图像，否则创建一个通道维度在前或在后的图像。
- 参数:
height – 图像的高度。该值应大于 2 * rad_max。
width – 图像的宽度。该值应大于 2 * rad_max。
num_objs – 生成的圆的数量。默认为 12。
rad_max – 最大圆半径。默认为 30。
rad_min – 最小圆半径。默认为 5。
noise_max – 如果大于 0，则会将从范围 [0, noise_max) 的均匀分布中提取的噪声添加到图像中。默认为 0。
num_seg_classes – 分割的类别数量。默认为 5。
channel_dim – 如果为 None，创建一个不带通道维度的图像，否则创建一个通道维度在前或在后的图像。默认为 None。
random_state – 要使用的随机生成器。默认为 np.random。
- 返回:
形状为 (height, width) 的随机 Numpy 数组
- monai.data.synthetic.create_test_image_3d(height, width, depth, num_objs=12, rad_max=30, rad_min=5, noise_max=0.0, num_seg_classes=5, channel_dim=None, random_state=None)[source]#
返回一个嘈杂的 3D 图像和分割。
- 参数:
height – 图像的高度。该值应大于 2 * rad_max。
width – 图像的宽度。该值应大于 2 * rad_max。
depth – 图像的深度。该值应大于 2 * rad_max。
num_objs – 生成的圆的数量。默认为 12。
rad_max – 最大圆半径。默认为 30。
rad_min – 最小圆半径。默认为 5。
noise_max – 如果大于 0，则会将从范围 [0, noise_max) 的均匀分布中提取的噪声添加到图像中。默认为 0。
num_seg_classes – 分割的类别数量。默认为 5。
channel_dim – 如果为 None，创建一个不带通道维度的图像，否则创建一个通道维度在前或在后的图像。默认为 None。
random_state – 要使用的随机生成器。默认为 np.random。
- 返回:
形状为 (height, width, depth) 的随机 Numpy 数组
输出文件夹布局#
- class monai.data.folder_layout.FolderLayout(output_dir, postfix='', extension='', parent=False, makedirs=False, data_root_dir='')[source]#
一个实用类，用于在
output_dir内创建有组织的文件名。可以使用filename方法创建遵循文件夹结构的文件名。示例
from monai.data import FolderLayout layout = FolderLayout( output_dir="/test_run_1/", postfix="seg", extension="nii", makedirs=False) layout.filename(subject="Sub-A", idx="00", modality="T1") # return value: "/test_run_1/Sub-A_seg_00_modality-T1.nii"
输出文件名是一个以
subjectID 开头的字符串，并包含关于自定义索引和图像模态的附加信息。这个实用类不会改变底层图像数据，但提供了一种创建文件的便捷方法。- __init__(output_dir, postfix='', extension='', parent=False, makedirs=False, data_root_dir='')[source]#
- 参数:
output_dir (
Union[str,PathLike]) – 输出目录。postfix (
str) – 输出文件名的后缀字符串，追加到subject之后。extension (
str) – 输出文件扩展名，将追加到输出文件名末尾。parent (
bool) – 是否在输出文件名中添加一层父文件夹来包含每张图像。makedirs (
bool) – 如果输出父目录不存在，是否创建它们。data_root_dir (
Union[str,PathLike]) – 一个可选的 PathLike 对象，用于保留输入 subject 的文件夹结构。详情请参阅monai.data.utils.create_file_basename()。
- filename(subject='subject', idx=None, **kwargs)[source]#
根据输入的
subject和idx创建文件名。输出文件名的格式为
output_dir/[subject/]subject[_postfix][_idx][_key-value][ext]- 参数:
subject (
Union[str,PathLike]) – 主体名称，用作输出文件名的主要 ID。当提供 PathLike 对象时，将使用基本文件名作为主体名称，忽略 subject 的扩展名，而使用此类的构造函数中的extension。idx – 图像的附加索引名称。
kwargs – 用于生成输出文件名的附加关键字参数。键值对将以
f"_{k}-{v}"的形式追加到输出文件名。
- 返回类型:
Union[str,PathLike]
- class monai.data.folder_layout.FolderLayoutBase[source]#
定义 FolderLayout 和派生类通用接口的抽象基类。主要定义了必须由派生类实现的
filename(**kwargs) -> PathLike函数。示例
from monai.data import FolderLayoutBase class MyFolderLayout(FolderLayoutBase): def __init__( self, basepath: Path, extension: str = "", makedirs: bool = False ): self.basepath = basepath if not extension: self.extension = "" elif extension.startswith("."): self.extension = extension: else: self.extension = f".{extension}" self.makedirs = makedirs def filename(self, patient_no: int, image_name: str, **kwargs) -> Path: sub_path = self.basepath / patient_no if not sub_path.exists(): sub_path.mkdir(parents=True) file = image_name for k, v in kwargs.items(): file += f"_{k}-{v}" file += self.extension return sub_path / file
- monai.data.folder_layout.default_name_formatter(metadict, saver)[source]#
根据输入的元数据和 SaveImage 变换，返回一个用于
FolderLayout.filename()的 kwargs 字典。- 返回类型:
dict
工具函数#
- monai.data.utils.affine_to_spacing(affine, r=3, dtype=<class 'float'>, suppress_zeros=True)[source]#
从仿射矩阵计算当前间距。
- 参数:
affine (~NdarrayTensor) – 一个 d x d 仿射矩阵。
r (
int) – 基于空间秩的索引，间距从 affine[:r, :r] 计算得出。dtype – 输出的数据类型。
suppress_zeros (
bool) – 是否用 1 抑制零。
- 返回类型:
~NdarrayTensor
- 返回:
一个 r 维的间距向量。
- monai.data.utils.compute_importance_map(patch_size, mode=constant, sigma_scale=0.125, device=cpu, dtype=torch.float32)[source]#
获取不同权重模式的重要性图。
- 参数:
patch_size – 所需重要性图的尺寸。应为 H, W [,D] 格式。
mode –
{
"constant","gaussian"} 如何融合重叠窗口的输出。默认为"constant"。"constant”：对所有预测给予同等权重。"gaussian”：对窗口边缘的预测给予较小权重。
sigma_scale – 用于计算每个维度 sigma 的缩放因子 (sigma = sigma_scale * dim_size)。仅用于 gaussian 模式。
device – 放置重要性图的设备。
dtype – 输出重要性图的数据类型。
- 抛出:
ValueError – 当
mode不在 [“constant”, “gaussian”] 中时。- 返回:
尺寸为 patch_size 的张量。
- monai.data.utils.compute_shape_offset(spatial_shape, in_affine, out_affine, scale_extent=False)[source]#
给定输入和输出仿射，根据输入数组的形状计算输出空间中适当的形状。此函数还返回偏移量，以便将形状在世界坐标系中置于良好位置。
- 参数:
spatial_shape – 输入数组的形状
in_affine (matrix) – 2D 仿射矩阵
out_affine (matrix) – 2D 仿射矩阵
scale_extent –
缩放是基于间距还是基于体素的完整范围进行计算，例如，对于缩放因子 0.5
选项 1，“o”代表一个体素，缩放体素之间的距离
o--o--o o-----o
选项 2，每个体素都有物理范围，缩放完整的体素范围
| voxel 1 | voxel 2 | voxel 3 | voxel 4 | | voxel 1 | voxel 2 |
选项 1 可以减少需要插值的区域数量。选项 2 更不依赖于分辨率，也就是说，重采样坐标取决于缩放因子，而不是体素数量。默认为 False，使用选项 1 计算形状和偏移量。
- monai.data.utils.convert_tables_to_dicts(dfs, row_indices=None, col_names=None, col_types=None, col_groups=None, **kwargs)[source]#
一个实用函数，用于连接 pandas 表格，选择行、列并生成组。将返回一个字典列表，每个字典对应表格中的一行数据。
- 参数:
dfs – pandas Dataframe 格式的数据表。如果提供表格列表，将连接它们。
row_indices – 要加载的预期行的索引。它应该是一个列表，每个项目可以是整数或表示范围[start, end)的列表。例如：row_indices=[[0, 100], 200, 201, 202, 300]。如果为 None，则加载文件中的所有行。
col_names – 要加载的预期列名。如果为 None，则加载所有列。
col_types –
用于转换加载列的 type 和 default value，如果为 None，则使用原始数据。它应该是一个字典，每个项对应一个预期的列，key 是列名，value 为 None 或一个用于定义默认值和数据类型的字典。字典中支持的键为：["type", "default"]，请注意 default 的值不应为 None。例如
col_types = { "subject_id": {"type": str}, "label": {"type": int, "default": 0}, "ehr_0": {"type": float, "default": 0.0}, "ehr_1": {"type": float, "default": 0.0}, }
col_groups – 用于将加载的列分组生成新列的参数，它应该是一个字典，每个项映射到一个组，key 将是新列名，value 是要组合的列名。例如：col_groups={“ehr”: [f”ehr_{i}” for i in range(10)], “meta”: [“meta_1”, “meta_2”]}
kwargs – 用于 pandas.merge() API 连接表格的额外参数。
- monai.data.utils.correct_nifti_header_if_necessary(img_nii)[source]#
检查 nifti 对象头的格式，如需要则更新头部信息。在更新后的图像中，pixdim 与 affine 匹配。
- 参数:
img_nii – nifti 图像对象
- monai.data.utils.create_file_basename(postfix, input_file_name, folder_path, data_root_dir='', separate_folder=True, patch_index=None, makedirs=True)[source]#
一个实用函数，根据输入文件名创建输出文件的路径（不添加文件扩展名）。当未指定
data_root_dir时，输出文件名格式为：folder_path/input_file_name (no ext.) /input_file_name (no ext.)[_postfix][_patch_index]
否则将插入相对于
data_root_dir的相对路径，例如from monai.data import create_file_basename create_file_basename( postfix="seg", input_file_name="/foo/bar/test1/image.png", folder_path="/output", data_root_dir="/foo/bar", separate_folder=True, makedirs=False) # output: /output/test1/image/image_seg
- 参数:
postfix (
str) – 输出名称的后缀input_file_name (
Union[str,PathLike]) – 输入图像文件的路径。folder_path (
Union[str,PathLike]) – 输出文件的路径。data_root_dir (
Union[str,PathLike]) – 如果非空，它指定输入文件绝对路径的起始部分。这用于计算 input_file_rel_path（从 data_root_dir 到文件的相对路径），以便在保存时保留文件夹结构，以防不同文件夹中的文件具有相同名称。separate_folder (
bool) – 是否将每个文件保存到单独的文件夹中，例如：如果输入文件名为 image.nii，后缀为 seg，folder_path 为 output，如果为 True，则保存为 output/image/image_seg.nii，如果为 False，则保存为 output/image_seg.nii。默认为 True。patch_index – 如果非 None，将 patch 索引追加到文件名。
makedirs (
bool) – 如果文件夹不存在，是否创建它。
- 返回类型:
str
- monai.data.utils.decollate_batch(batch, detach=True, pad=True, fill_value=None)[source]#
解批处理一批数据（例如，由 DataLoader 产生的数据）。
返回一个结构列表，其中原始张量的第 0 维度使用 torch.unbind 切片成各个元素。
原始存储为 (B,C,H,W,[D]) 的图像将返回为 (C,H,W,[D])。其他信息（例如元数据）可能存储在列表中（或嵌套字典中的列表）。在这种情况下，我们返回列表中对应于批次索引的元素。
返回类型不保证与原始类型相同，因为 numpy 数组可能已转换为 torch.Tensor，序列可能已转换为张量列表，映射可能已转换为字典。
示例
batch_data = { "image": torch.rand((2,1,10,10)), DictPostFix.meta("image"): {"scl_slope": torch.Tensor([0.0, 0.0])} } out = decollate_batch(batch_data) print(len(out)) >>> 2 print(out[0]) >>> {'image': tensor([[[4.3549e-01...43e-01]]]), DictPostFix.meta("image"): {'scl_slope': 0.0}} batch_data = [torch.rand((2,1,10,10)), torch.rand((2,3,5,5))] out = decollate_batch(batch_data) print(out[0]) >>> [tensor([[[4.3549e-01...43e-01]]], tensor([[[5.3435e-01...45e-01]]])] batch_data = torch.rand((2,1,10,10)) out = decollate_batch(batch_data) print(out[0]) >>> tensor([[[4.3549e-01...43e-01]]]) batch_data = { "image": [1, 2, 3], "meta": [4, 5], # undetermined batch size } out = decollate_batch(batch_data, pad=True, fill_value=0) print(out) >>> [{'image': 1, 'meta': 4}, {'image': 2, 'meta': 5}, {'image': 3, 'meta': 0}] out = decollate_batch(batch_data, pad=False) print(out) >>> [{'image': 1, 'meta': 4}, {'image': 2, 'meta': 5}]
- 参数:
batch – 要进行解批处理的数据。
detach (
bool) – 是否分离张量。标量张量将分离成数字类型而不是 torch 张量。pad – 当批次中的项指示不同的批次大小时，是否将所有序列填充到最长。如果为 False，批次大小将是最短序列的长度。
fill_value – 当 pad 为 True 时，填充时使用的 fillvalue，默认为 None。
- monai.data.utils.dense_patch_slices(image_size, patch_size, scan_interval, return_slice=True)[source]#
从 image_size 输入图像中枚举定义尺寸为 patch_size 的 ND patch 的所有切片。
- 参数:
image_size (
Sequence[int]) – 要遍历的图像维度patch_size (
Sequence[int]) – 用于生成切片的 patch 尺寸scan_interval (
Sequence[int]) – 密集 patch 采样间隔return_slice (
bool) – 是否返回切片列表（或索引元组），默认为 True
- 返回类型:
list[tuple[slice, …]]- 返回:
定义每个 patch 的切片对象列表
- monai.data.utils.get_extra_metadata_keys()[source]#
获取一个可以移除的不必要元数据键列表。
- 返回类型:
list[str]- 返回:
要移除的键列表。
- monai.data.utils.get_random_patch(dims, patch_size, rand_state=None)[source]#
返回一个切片元组，用于在形状为 dims 的数组中定义一个大小为 patch_size 的随机 patch，或者在给定维度内尽可能接近此大小的 patch。预计 patch_size 是对于形状为 dims 的源有效的 patch，如 get_valid_patch_size 返回的值。
- 参数:
dims – 源数组的形状
patch_size – 要生成的 patch 尺寸的形状
rand_state – 用于生成随机数的随机状态对象
- 返回:
定义 patch 的切片对象元组
- 返回类型:
(tuple of slice)
- monai.data.utils.get_valid_patch_size(image_size, patch_size)[source]#
给定一个维度为 image_size 的图像，如果 patch_size 不为 0 或 None，则返回一个从 patch_size 获取维度的 patch 尺寸元组。否则，或如果 patch_size 比 image_size 短，则取 image_size 的维度。这确保返回的 patch 尺寸在 image_size 的范围内。如果 patch_size 是一个单独的数字，则将其解释为与 image_size 具有相同维度，并在每个维度上具有该大小的 patch。
- monai.data.utils.is_no_channel(val)[source]#
返回 val 是否表示“no_channel”，对应于 MetaKeys.ORIGINAL_CHANNEL_DIM。
- 返回类型:
bool
- monai.data.utils.is_supported_format(filename, suffixes)[source]#
验证指定的文件或文件格式是否与支持的后缀匹配。如果支持的后缀为 None，则跳过验证并返回 True。
- 参数:
filename – 要读取的文件名或文件名列表。如果是文件列表，则验证所有后缀。
suffixes – 当前读取器支持的所有图像后缀，必须是小写后缀列表。
- monai.data.utils.iter_patch(arr, patch_size=0, start_pos=(), overlap=0.0, copy_back=True, mode=wrap, **pad_opts)[source]#
从 arr 中以尺寸 patch_size 逐个生成 patch。迭代可以从 arr 的 start_pos 位置开始，但从每个维度扩展了 patch_size 的填充数组中提取（因此这些坐标可以是负数以从填充区域开始）。如果 copy_back 为 True，则每个 patch 的值将被写回 arr。
- 参数:
arr – 要遍历的数组
patch_size – 要生成切片的 patch 尺寸，0 或 None 选择整个维度。对于 0 或 None，对应维度的填充和重叠比例将为 0。
start_pos – 数组中的起始位置，默认每个维度为 0。
overlap – 相邻 patch 在每个维度上的重叠量（一个介于 0.0 和 1.0 之间的值）。如果只给一个浮点数，它将应用于所有维度。默认为 0.0。
copy_back – 如果为 True，则在生成器完成迭代后，生成的 patch 中的数据将被复制回 arr。
mode – 可用模式：（Numpy）{
"constant","edge","linear_ramp","maximum","mean","median","minimum","reflect","symmetric","wrap","empty"}（PyTorch）{"constant","reflect","replicate","circular"}。列表中的字符串值之一或用户提供的函数。如果为 None，则不执行填充。默认为"wrap"。另请参阅：https://numpy.com.cn/doc/stable/reference/generated/numpy.pad.html https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html 需要 pytorch >= 1.10 获得最佳兼容性。pad_opts – np.pad 或 torch.pad 函数的其他参数。注意 np.pad 将通道维度视为第一个维度。
- 生成:
从 arr 中生成的数组数据 patch，这些 patch 是填充数组的视图，可以修改。如果 copy_back 为 True，这些更改将在迭代完成后反映到 arr 中。
注意
坐标格式为
- [1st_dim_start, 1st_dim_end,
2nd_dim_start, 2nd_dim_end, …, Nth_dim_start, Nth_dim_end]]
- monai.data.utils.iter_patch_position(image_size, patch_size, start_pos=(), overlap=0.0, padded=False)[source]#
从维度为 image_size 的数组中，生成尺寸为 patch_size 的 patch 左上角位置的连续元组。迭代从数组中的 start_pos 位置开始，如果未提供则从原点开始。每个 patch 在连续网格中以行优先顺序选取。
- 参数:
image_size – 要遍历的数组维度
patch_size – 要生成切片的 patch 尺寸，0 或 None 选择整个维度
start_pos – 数组中的起始位置，默认每个维度为 0。
overlap – 相邻 patch 在每个维度上的重叠量。可以是 0.0 到 1.0 之间的浮点数或浮点数列表来定义相对于 patch 尺寸的重叠，也可以是整数或整数列表来定义重叠的像素数量。如果只给一个浮点数/整数，它将应用于所有维度。默认为 0.0。
padded – 图像是否被填充，以便 patch 可以超出边界。默认为 False。
- 生成:
定义每个 patch 左上角位置的元组
- monai.data.utils.iter_patch_slices(image_size, patch_size, start_pos=(), overlap=0.0, padded=True)[source]#
从维度为 image_size 的数组中，生成定义尺寸为 patch_size 的 patch 的连续切片元组。迭代从数组中的 start_pos 位置开始，如果未提供则从原点开始。每个 patch 在连续网格中以行优先顺序选取。
- 参数:
image_size – 要遍历的数组维度
patch_size – 要生成切片的 patch 尺寸，0 或 None 选择整个维度
start_pos – 数组中的起始位置，默认每个维度为 0。
overlap – 相邻 patch 在每个维度上的重叠量（一个介于 0.0 和 1.0 之间的值）。如果只给一个浮点数，它将应用于所有维度。默认为 0.0。
padded – 图像是否被填充，以便 patch 可以超出边界。默认为 False。
- 生成:
定义每个 patch 的切片对象元组
- bytes
monai.data.utils.list_data_collate(batch)[source]#
注意
PyTorch DataLoader 默认 collate 的增强。如果数据集已经返回转换中生成的批次数据列表，需要将所有数据合并到一个列表中。然后与默认 collate 行为相同。
- 不执行任何 collation 操作。
monai.data.utils.orientation_ras_lps(affine)[source]#
- 参数:
通过翻转前两个空间维度，在 RAS 和 LPS 方向之间转换
affine。- 返回类型:
~NdarrayTensor
- affine (~NdarrayTensor) – 一个 2D 仿射矩阵。
monai.data.utils.pad_list_data_collate(batch, method=symmetric, mode=constant, **kwargs)[source]#
monai.transforms.croppad.batch.PadListDataCollate的函数版本。与 MONAI 的
list_data_collate相同，不同之处在于任何张量都被中心填充以匹配每个维度中最大张量的形状。如果某些应用的转换生成不同大小的批次数据，此转换很有用。- 参数:
这可用于列表和字典数据。请注意，对于字典数据，如果输入批次具有不同的空间形状，此解批处理函数可能会将 PadListDataCollate 的转换信息添加到可逆转换列表中，因此在反转其他转换之前需要调用静态方法：monai.transforms.croppad.batch.PadListDataCollate.inverse。
batch (
Sequence) – 要填充-合并的数据批次method (
str) – 填充方法（参见monai.transforms.SpatialPad）mode (
str) – 填充模式（参见monai.transforms.SpatialPad）
- kwargs – np.pad 或 torch.pad 函数的其他参数。注意 np.pad 将通道维度视为第一个维度。
将数据集分成 N 个分区。它可以根据指定的随机种子支持 shuffle。将返回一个数据集集合，每个数据集包含原始数据集的 1 个分区。它可以根据指定的比例或平均分割成 num_partitions。参考：https://pytorch.ac.cn/docs/stable/distributed.html#module-torch.distributed.launch。
注意
它也可用于为分布式训练中的 ranks 分区数据集。例如，在训练前分区数据集并使用 CacheDataset，每个 rank 使用自己的数据进行训练。这可以避免每个 rank 中重复的缓存内容，但不会在每个 epoch 之前进行全局 shuffle
data_partition = partition_dataset( data=train_files, num_partitions=dist.get_world_size(), shuffle=True, even_divisible=True, )[dist.get_rank()] train_ds = SmartCacheDataset( data=data_partition, transform=train_transforms, replace_rate=0.2, cache_num=15, )
- 参数:
data – 输入数据集以进行分割，期望是一个数据列表。
ratios – 分割数据集的比例数字列表，例如 [8, 1, 1]。
num_partitions – 期望的平均分割分区数量，仅在未指定 ratios 时有效。
shuffle – 在分割前是否 shuffle 原始数据集。
seed – 用于 shuffle 数据集的随机种子，仅在 shuffle 为 True 时有效。
drop_last – 仅在 even_divisible 为 False 且未指定 ratios 时有效。如果为 True，将丢弃数据的尾部以使其能在分区之间均匀分割。如果为 False，将添加额外的索引以使数据能在分区之间均匀分割。
even_divisible – 如果为 True，则保证每个分区具有相同的长度。
示例
>>> data = [1, 2, 3, 4, 5] >>> partition_dataset(data, ratios=[0.6, 0.2, 0.2], shuffle=False) [[1, 2, 3], [4], [5]] >>> partition_dataset(data, num_partitions=2, shuffle=False) [[1, 3, 5], [2, 4]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=True, drop_last=True) [[1, 3], [2, 4]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=True, drop_last=False) [[1, 3, 5], [2, 4, 1]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=False, drop_last=False) [[1, 3, 5], [2, 4]]
- monai.data.utils.partition_dataset_classes(data, classes, ratios=None, num_partitions=None, shuffle=False, seed=0, drop_last=False, even_divisible=False)[source]#
根据给定的类别标签将数据集分割成 N 个分区。它可以确保每个分区中的类别比例相同。其他方面与
monai.data.partition_dataset相同。- 参数:
data – 输入数据集以进行分割，期望是一个数据列表。
classes – 用于帮助分割数据的标签列表，长度必须与数据的长度匹配。
ratios – 分割数据集的比例数字列表，例如 [8, 1, 1]。
num_partitions – 期望的平均分割分区数量，仅在未指定 ratios 时有效。
shuffle – 在分割前是否 shuffle 原始数据集。
seed – 用于 shuffle 数据集的随机种子，仅在 shuffle 为 True 时有效。
drop_last – 仅在 even_divisible 为 False 且未指定 ratios 时有效。如果为 True，将丢弃数据的尾部以使其能在分区之间均匀分割。如果为 False，将添加额外的索引以使数据能在分区之间均匀分割。
even_divisible – 如果为 True，则保证每个分区具有相同的长度。
示例
>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> classes = [2, 0, 2, 1, 3, 2, 2, 0, 2, 0, 3, 3, 1, 3] >>> partition_dataset_classes(data, classes, shuffle=False, ratios=[2, 1]) [[2, 8, 4, 1, 3, 6, 5, 11, 12], [10, 13, 7, 9, 14]]
- monai.data.utils.pickle_hashing(item, protocol=5)[source]#
- 参数:
item – 要进行哈希计算的数据项
protocol – 用于 pickle 的协议版本，默认为 pickle.HIGHEST_PROTOCOL。
返回:
- 返回类型:
相应的哈希键
- monai.data.utils.rectify_header_sform_qform(img_nii)[source]#
查看 nifti 对象的 sform 和 qform，并在与像素维度不兼容时进行更正
改编自 NifTK/NiftyNet
- 参数:
img_nii – nifti 图像对象
- monai.data.utils.remove_extra_metadata(meta)[source]#
从字典中移除额外元数据。操作在原地进行，因此没有返回值。
- 参数:
meta (
dict) – 包含待修改元数据的字典。- 返回类型:
None- 返回:
None
- monai.data.utils.remove_keys(data, keys)[source]#
从字典中移除键。操作在原地进行，因此没有返回值。
- 参数:
data (
dict) – 待修改的字典。keys (
list[str]) – 要从字典中删除的键。
- 返回类型:
None- 返回:
None
- monai.data.utils.reorient_spatial_axes(data_shape, init_affine, target_affine)[source]#
给定输入
init_affine，通过重新排列/翻转轴来计算其与target_affine之间的方向变换。返回方向变换和更新后的仿射变换矩阵（Tensor 或 ndarray 取决于输入
affine的数据类型）。请注意，此函数需要外部模块nibabel.orientations。- 返回类型:
tuple[ndarray,Union[ndarray,Tensor]]
- monai.data.utils.resample_datalist(data, factor, random_pick=False, seed=0)[source]#
用于重采样加载的数据列表以进行训练的实用函数，例如：如果 factor < 1.0，则随机选取数据列表的一部分并设置为 Dataset，这有助于快速测试程序。如果 factor > 1.0，则重复数据列表以增强 Dataset。
- 参数:
data (
Sequence) – 原始数据列表以进行缩放。factor (
float) – 数据列表的比例因子，例如，factor=4.5，重复数据列表 4 次并加上原始数据列表的 50%。random_pick (
bool) – 如果比例因子有小数部分，是否随机选取数据。seed (
int) – 随机选取数据的随机种子。
- monai.data.utils.select_cross_validation_folds(partitions, folds)[source]#
根据数据分区和指定的折叠索引选择交叉验证数据。如果提供了折叠索引列表，则连接这些折叠的分区。
- 参数:
partitions – 数据集序列，每个项目都是可迭代的
folds – 要组合的分区的索引。
- 返回:
组合数据集列表。
示例
>>> partitions = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]] >>> select_cross_validation_folds(partitions, 2) [5, 6] >>> select_cross_validation_folds(partitions, [1, 2]) [3, 4, 5, 6] >>> select_cross_validation_folds(partitions, [-1, 2]) [9, 10, 5, 6]
- monai.data.utils.set_rnd(obj, seed)[source]#
为 obj 的所有可随机属性设置种子或随机状态。
- 参数:
obj – 要为其设置种子或随机状态的对象。
seed (
int) – 用整数种子设置随机状态。
- 返回类型:
int
- monai.data.utils.to_affine_nd(r, affine, dtype=<class 'numpy.float64'>)[source]#
使用 affine 中的元素，通过分配旋转/缩放矩阵和平移向量来创建一个新的仿射变换矩阵。
当
r是整数时，输出是 (r+1)x(r+1) 矩阵，其中左上角 kxk 的元素从affine复制，输出仿射变换的最后一列从affine的最后一列复制。k 由 min(r, len(affine) - 1) 确定。当
r是仿射变换矩阵时，输出与r具有相同的形状，且左上角 kxk 的元素从affine复制，输出仿射变换的最后一列从affine的最后一列复制。k 由 min(len(r) - 1, len(affine) - 1) 确定。- 参数:
r (int or matrix) – 空间维度数或待填充的输出仿射变换矩阵。
affine (matrix) – 2D 仿射变换矩阵
dtype – 输出数组的数据类型。
- 抛出:
ValueError – 当
affine的维度不为 2。ValueError – 当
r为非正数时。
- 返回:
一个 (r+1) x (r+1) 矩阵（Tensor 或 ndarray 取决于输入
affine的数据类型）
- monai.data.utils.worker_init_fn(worker_id)[source]#
用于 PyTorch DataLoader worker_init_fn 的回调函数。它可以在不同的 workers 中为 transforms 设置不同的随机种子。
- 返回类型:
None
- monai.data.utils.zoom_affine(affine, scale, diagonal=True)[source]#
使 affine 的列范数与 scale 相同。如果 diagonal 为 False，则返回一个结合了正交旋转和新 scale 的仿射变换矩阵。这是通过首先分解 affine，然后将缩放因子设置为 scale，并组合一个新的仿射变换矩阵来完成的；剪切因子被移除。如果 diagonal 为 True，则返回一个对角矩阵，缩放因子被设置为对角元素。此函数总是返回一个平移为零的仿射变换矩阵。
- 参数:
affine (nxn matrix) – 方阵。
scale – 沿每个维度的新缩放因子。如果 scale 的分量为非正值，将使用从 affine 计算出的原始 pixdim 的相应分量。
diagonal – 是否返回对角缩放矩阵。默认为 True。
- 抛出:
ValueError – 当
affine不是方阵时。ValueError – 当
scale包含非正标量时。
- 返回:
更新后的 n x n 仿射变换矩阵。
分割数据集#
- monai.data.partition_dataset(data, ratios=None, num_partitions=None, shuffle=False, seed=0, drop_last=False, even_divisible=False)[source]#
将数据集分成 N 个分区。它可以根据指定的随机种子支持 shuffle。将返回一个数据集集合，每个数据集包含原始数据集的 1 个分区。它可以根据指定的比例或平均分割成 num_partitions。参考：https://pytorch.ac.cn/docs/stable/distributed.html#module-torch.distributed.launch。
注意
它也可用于为分布式训练中的 ranks 分区数据集。例如，在训练前分区数据集并使用 CacheDataset，每个 rank 使用自己的数据进行训练。这可以避免每个 rank 中重复的缓存内容，但不会在每个 epoch 之前进行全局 shuffle
data_partition = partition_dataset( data=train_files, num_partitions=dist.get_world_size(), shuffle=True, even_divisible=True, )[dist.get_rank()] train_ds = SmartCacheDataset( data=data_partition, transform=train_transforms, replace_rate=0.2, cache_num=15, )
- 参数:
data – 输入数据集以进行分割，期望是一个数据列表。
ratios – 分割数据集的比例数字列表，例如 [8, 1, 1]。
num_partitions – 期望的平均分割分区数量，仅在未指定 ratios 时有效。
shuffle – 在分割前是否 shuffle 原始数据集。
seed – 用于 shuffle 数据集的随机种子，仅在 shuffle 为 True 时有效。
drop_last – 仅在 even_divisible 为 False 且未指定 ratios 时有效。如果为 True，将丢弃数据的尾部以使其能在分区之间均匀分割。如果为 False，将添加额外的索引以使数据能在分区之间均匀分割。
even_divisible – 如果为 True，则保证每个分区具有相同的长度。
示例
>>> data = [1, 2, 3, 4, 5] >>> partition_dataset(data, ratios=[0.6, 0.2, 0.2], shuffle=False) [[1, 2, 3], [4], [5]] >>> partition_dataset(data, num_partitions=2, shuffle=False) [[1, 3, 5], [2, 4]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=True, drop_last=True) [[1, 3], [2, 4]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=True, drop_last=False) [[1, 3, 5], [2, 4, 1]] >>> partition_dataset(data, num_partitions=2, shuffle=False, even_divisible=False, drop_last=False) [[1, 3, 5], [2, 4]]
基于类别分割数据集#
- monai.data.partition_dataset_classes(data, classes, ratios=None, num_partitions=None, shuffle=False, seed=0, drop_last=False, even_divisible=False)[source]#
根据给定的类别标签将数据集分割成 N 个分区。它可以确保每个分区中的类别比例相同。其他方面与
monai.data.partition_dataset相同。- 参数:
data – 输入数据集以进行分割，期望是一个数据列表。
classes – 用于帮助分割数据的标签列表，长度必须与数据的长度匹配。
ratios – 分割数据集的比例数字列表，例如 [8, 1, 1]。
num_partitions – 期望的平均分割分区数量，仅在未指定 ratios 时有效。
shuffle – 在分割前是否 shuffle 原始数据集。
seed – 用于 shuffle 数据集的随机种子，仅在 shuffle 为 True 时有效。
drop_last – 仅在 even_divisible 为 False 且未指定 ratios 时有效。如果为 True，将丢弃数据的尾部以使其能在分区之间均匀分割。如果为 False，将添加额外的索引以使数据能在分区之间均匀分割。
even_divisible – 如果为 True，则保证每个分区具有相同的长度。
示例
>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> classes = [2, 0, 2, 1, 3, 2, 2, 0, 2, 0, 3, 3, 1, 3] >>> partition_dataset_classes(data, classes, shuffle=False, ratios=[2, 1]) [[2, 8, 4, 1, 3, 6, 5, 11, 12], [10, 13, 7, 9, 14]]
分布式采样器#
- class monai.data.DistributedSampler(dataset, even_divisible=True, num_replicas=None, rank=None, shuffle=True, **kwargs)[source]#
增强 PyTorch DistributedSampler 以支持非均匀可分割采样。
- 参数:
dataset – 用于采样的 Dataset。
even_divisible – 如果为 False，不同 ranks 的数据长度可能不同。例如，输入数据：[1, 2, 3, 4, 5]，rank 0：[1, 3, 5]，rank 1：[2, 4]。
num_replicas – 参与分布式训练的进程数。默认情况下，从当前分布式组中检索 world_size。
rank – 当前进程在 num_replicas 中的 rank。默认情况下，从当前分布式组中检索 rank。
shuffle – 如果为 True，采样器将 shuffle 索引，默认为 True。
kwargs – DistributedSampler 超类的附加参数，可以是 seed 和 drop_last。
有关 DistributedSampler 的更多信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.distributed.DistributedSampler。
分布式加权随机采样器#
- class monai.data.DistributedWeightedRandomSampler(dataset, weights, num_samples_per_rank=None, generator=None, even_divisible=True, num_replicas=None, rank=None, **kwargs)[source]#
扩展 DistributedSampler 以支持加权采样。参考 torch.utils.data.WeightedRandomSampler，更多详情请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.WeightedRandomSampler。
- 参数:
dataset – 用于采样的 Dataset。
weights – 权重序列，不必总和为一，长度应与完整数据集完全匹配。
num_samples_per_rank – 每个 rank 抽取的样本数量，从分布式数据集的子集中采样。如果为 None，默认为 DistributedSampler 分割的数据集长度。
generator – 采样中使用的 PyTorch Generator。
even_divisible – 如果为 False，不同 ranks 的数据长度可能不同。例如，输入数据：[1, 2, 3, 4, 5]，rank 0：[1, 3, 5]，rank 1：[2, 4]。’
num_replicas – 参与分布式训练的进程数。默认情况下，从当前分布式组中检索 world_size。
rank – 当前进程在 num_replicas 中的 rank。默认情况下，从当前分布式组中检索 rank。
kwargs – DistributedSampler 超类的附加参数，可以是 seed 和 drop_last。
数据集摘要#
- class monai.data.DatasetSummary(dataset, image_key='image', label_key='label', meta_key=None, meta_key_postfix='meta_dict', num_workers=0, **kwargs)[source]#
此类提供了一种根据输入数据集计算合理输出体素间距的方法。获得的值可用于在 3d 分割任务中对输入进行重采样（例如用作 monai.transforms.Spacingd 中的 pixdim 参数）。此外，它还支持计算输入的平均值、标准差、最小值和最大强度，这些统计数据有助于图像归一化（作为 monai.transforms.ScaleIntensityRanged 和 monai.transforms.NormalizeIntensityd 的参数）。
计算算法参考：Automated Design of Deep Learning Methods for Biomedical Image Segmentation。
Decathlon 数据列表#
- monai.data.load_decathlon_datalist(data_list_file_path, is_segmentation=True, data_list_key='training', base_dir=None)[source]#
从 JSON 文件加载 decathlon 挑战赛的图像/标签路径
Json 文件与您从 http://medicaldecathlon.com/ 获得的类似。那些 dataset.json 文件
- 参数:
data_list_file_path – datalist 的 json 文件路径。
is_segmentation – datalist 是否用于分割任务，默认为 True。
data_list_key – 获取要使用的字典列表的键，默认为“training”。
base_dir – 数据集的根目录，如果为 None，则使用 datalist 所在的目录。
- 抛出:
ValueError – 当
data_list_file_path不指向文件时。ValueError – 当数据列表文件中未指定
data_list_key时。
返回数据项列表，每个数据项都是一个以元素名称为键的字典，例如
[ {'image': '/workspace/data/chest_19.nii.gz', 'label': 0}, {'image': '/workspace/data/chest_31.nii.gz', 'label': 1} ]
- monai.data.load_decathlon_properties(data_property_file_path, property_keys)[source]#
从包含指定 property_keys 数据属性的 JSON 文件加载属性。
- 参数:
data_property_file_path – 数据属性 JSON 文件路径。
property_keys – 期望从 JSON 文件加载的键，例如，在 decathlon 挑战赛中，我们有这些键：name、description、reference、licence、tensorImageSize、modality、labels、numTraining、numTest 等。
- monai.data.check_missing_files(datalist, keys, root_dir=None, allow_missing_keys=False)[source]#
检查 Decathlon datalist 中的某些文件是否缺失。这有助于在繁重的训练运行前检查缺失文件。
- 参数:
datalist – 数据项列表，每个项都是一个字典。通常由 load_decathlon_datalist API 生成。
keys – datalist 中期望检查的键。
root_dir – 如果不为 None，则提供 datalist 中相对文件路径的根目录。
allow_missing_keys – 是否允许 datalist 项中存在缺失键。如果为 False，则在缺失时引发异常。默认为 False。
- 返回:
缺失文件名列表。
- monai.data.create_cross_validation_datalist(datalist, nfolds, train_folds, val_folds, train_key='training', val_key='validation', filename=None, shuffle=True, seed=0, check_missing=False, keys=None, root_dir=None, allow_missing_keys=False, raise_error=True)[source]#
根据交叉验证分区创建新的 Decathlon 风格数据列表的实用程序。
- 参数:
datalist – 所有要分区的项目的字典加载列表。
nfolds – kfold 分割的数量。
train_folds – 用于训练部分的折叠索引。
val_folds – 用于验证部分的折叠索引。
train_key – 新数据列表中训练部分的键，默认为“training”。
val_key – 新数据列表中验证部分的键，默认为“validation”。
filename – 如果不为 None 且以“.json”结尾，将新数据列表保存到 JSON 文件中。
shuffle – 在分区前是否 shuffle 数据列表，默认为 True。
seed – 如果 shuffle 为 True，设置随机种子，默认为 0。
check_missing – 是否检查 keys 指定的所有文件是否存在。
keys – 如果不为 None 且 check_missing_files 为 True，则为期望在数据列表中检查的键。
root_dir – 如果不为 None，则提供 datalist 中相对文件路径的根目录。
allow_missing_keys – 如果 check_missing_files 为 True，是否允许数据列表项中存在缺失键。如果为 False，则在缺失时引发异常。默认为 False。
raise_error – 当发现缺失文件时，如果为 True，则引发异常并停止；如果为 False，则打印警告。
数据加载器#
- class monai.data.DataLoader(dataset, num_workers=0, **kwargs)[source]#
提供对给定 dataset 的可迭代访问。它继承了 PyTorch DataLoader，并默认添加了增强的 collate_fn 和 worker_fn。
虽然可以将此类配置为与 torch.utils.data.DataLoader 相同，但建议使用其默认配置，主要原因在于以下附加功能：
它处理 MONAI 的 randomizable 对象，并进行适当的随机状态管理以实现确定性行为。
它感知基于 patch 的 transform（例如
monai.transforms.RandSpatialCropSamplesDict）样本，用于增强数据 collating 行为的预处理。参见：monai.transforms.Compose。
有关
torch.utils.data.DataLoader的更多详细信息，请查阅：https://pytorch.ac.cn/docs/stable/data.html#torch.utils.data.DataLoader。例如，构建一个随机化数据集并使用数据加载器进行迭代：
import torch from monai.data import DataLoader from monai.transforms import Randomizable class RandomDataset(torch.utils.data.Dataset, Randomizable): def __getitem__(self, index): return self.R.randint(0, 1000, (1,)) def __len__(self): return 16 dataset = RandomDataset() dataloader = DataLoader(dataset, batch_size=2, num_workers=4) for epoch in range(2): for i, batch in enumerate(dataloader): print(epoch, i, batch.data.numpy().flatten().tolist())
- 参数:
dataset (
Dataset) – 用于加载数据的 Dataset。num_workers (
int) – 用于数据加载的子进程数量。0表示数据将在主进程中加载。（默认值：0）collate_fn – 默认为
monai.data.utils.list_data_collate()。worker_init_fn – 默认为
monai.data.utils.worker_init_fn()。kwargs – PyTorch DataLoader 的其他参数。
线程缓冲区#
- class monai.data.ThreadBuffer(src, buffer_size=1, timeout=0.01)[source]#
在单独的线程中迭代 self.src 中的值，但在当前线程中产生这些值。这允许值异步排队。内部线程将继续运行，只要源有值或直到调用 stop() 方法。
以这种方式使用线程引发的一个问题是，在线程的生命周期内，源对象正在被迭代，因此如果线程尚未完成，则再次尝试迭代它将引发异常或产生意外结果。为了确保线程释放迭代并进行适当的清理，必须调用 stop() 方法，该方法将与线程进行 join。
- 参数:
src – 源数据可迭代对象
buffer_size (
int) – 从源缓冲的项目数timeout (
float) – 等待从缓冲区获取项目或在添加项目时等待缓冲区已满的时间
线程数据加载器#
- class monai.data.ThreadDataLoader(dataset, buffer_size=1, buffer_timeout=0.01, repeats=1, use_thread_workers=False, **kwargs)[source]#
继承 DataLoader 的子类，使用 ThreadBuffer 对象异步实现 __iter__ 方法。它将按预期迭代来自加载器的数据，但数据在单独的线程上生成。在需要 DataLoader 实例而不仅仅是可迭代对象的情况下使用此类。
当 repeats 设置为 1 时，默认行为是生成每个批次即yield。然而，当值更高时，生成的批次会被yield多次，同时底层数据集异步生成下一个批次。通常，一个批次中的所有相关信息无法在一次迭代中完全学到，因此对同一批次进行多次训练仍然可以产生良好的训练结果，同时最大程度地减少短期过拟合，并允许较慢的批次生成过程有更多的时间产生结果。这种重复是通过简单地多次yield同一个对象来完成的，而不是通过重新生成数据。
另一种典型用法是加速轻量级预处理（通常缓存所有确定性 transform 且没有 IO 操作），因为它利用单独的线程执行预处理，以避免 DataLoader 多个 worker 之间不必要的 IPC。并且由于 CUDA 与 DataLoader 的多进程可能不兼容，ThreadDataLoader 对于 GPU transform 可能很有用。更多详细信息：Project-MONAI/tutorials。
use_thread_workers 将导致 worker 创建为线程而不是进程，尽管类的工作方式其他方面保持不变。这允许在 Windows 等环境中或任何其他需要线程语义的情况下使用多个 worker。请注意，MONAI 的某些组件（例如一些数据集和随机 transform）不是线程安全的，启用 use_thread_workers 后可能无法按预期工作，启用 use_thread_workers 之前需要仔细检查所有预处理组件。
- 参见
Fischetti et al. “Faster SGD training by minibatch persistency.” ArXiv (2018) https://arxiv.org/abs/1806.07353
Dami et al., “Faster Neural Network Training with Data Echoing” ArXiv (2020) https://arxiv.org/abs/1907.05550
Ramezani et al. “GCN meets GPU: Decoupling “When to Sample” from “How to Sample”.” NeurIPS (2020). https://proceedings.neurips.cc/paper/2020/file/d714d2c5a796d5814c565d78dd16188d-Paper.pdf
- 参数:
dataset (
Dataset) – 输入数据集。buffer_size (
int) – 从数据源缓冲的项目数量。buffer_timeout (
float) – 等待从缓冲区获取项目的时间，或在添加项目时等待缓冲区满的时间。repeats (
int) – yielding 同一批次的次数。use_thread_workers (
bool) – 如果为 True 且 num_workers > 0，则 worker 将创建为线程而不是进程。kwargs – DataLoader 的其他参数，除了 dataset。
测试时增强#
- class monai.data.TestTimeAugmentation(transform, batch_size, num_workers=0, inferrer_fn=<function _identity>, device='cpu', image_key=image, orig_key=label, nearest_interp=True, orig_meta_keys=None, meta_key_postfix='meta_dict', to_tensor=True, output_device='cpu', post_func=<function _identity>, return_full_data=False, progress=True)[source]#
用于执行测试时增强的类。它将同一图像多次通过网络。
用户传入要应用于每个实现的 transform，并且只要其中至少一个 transform 是随机的，网络的输出就会变化。如果存在所有提供的空间 transform 的逆变换，则可以将逆变换应用于网络输出的每个实现。一旦它们位于同一空间参考中，就可以组合结果并计算指标。
测试时增强是计算网络不确定性以及观察网络对应用随机 transform 的依赖性的有用功能。
- 参考
Wang et al., Aleatoric uncertainty estimation with test-time augmentation for medical image segmentation with convolutional neural networks, https://doi.org/10.1016/j.neucom.2019.01.103
- 参数:
transform – 要应用于每个实现的 transform（或组合）。至少一个 transform 必须是以下类型：
RandomizableTrait (即 Randomizable、RandomizableTransform 或 RandomizableTrait) – 。所有随机 transform 都必须是 InvertibleTransform 类型。
batch_size – 一次推理的实现数量。
num_workers – 用于数据的子进程数量。
inferrer_fn – 用于执行推理的函数。
device – 执行推理的设备。
image_key – 用于从输入字典中提取图像的键。
orig_key – 字典中原始输入数据的键。将获取此输入数据已应用的 transform 信息，然后为期望数据（使用 image_key 指定）逆变换它们。
orig_meta_keys – 原始输入数据的元数据的键，将获取 affine、data_shape 等。元数据是一个字典对象，包含：文件名、原始形状等。如果为 None，将尝试通过 {orig_key}_{meta_key_postfix} 构建 meta_keys。
meta_key_postfix – 使用 key_{postfix} 根据 key 数据获取元数据，默认为 meta_dict，元数据是一个字典对象。例如，要处理 key image，从元数据 image_meta_dict 字典的 affine 字段读取/写入仿射变换矩阵。此参数仅在 meta_keys=None 时有效。
to_tensor – 是否先将逆变换后的数据转换为 PyTorch Tensor，默认为 True。
output_device – 如果将逆变换后的数据转换为 Tensor，在 post_func 之前将逆变换结果移动到目标设备，默认为“cpu”。
post_func – 逆变换后数据的后处理，应该是一个可调用函数。
return_full_data – 通常返回指标（mode, mean, std, vvc）。将此标志设置为 True 将返回完整数据。维度大小将与单个图像通过 inferrer_fn 时的维度相同，并附加一个等于 num_examples (N) 大小的维度，即 [N,C,H,W,[D]]。
progress – 是否显示进度条。
示例
model = UNet(...).to(device) transform = Compose([RandAffined(keys, ...), ...]) transform.set_random_state(seed=123) # ensure deterministic evaluation tt_aug = TestTimeAugmentation( transform, batch_size=5, num_workers=0, inferrer_fn=model, device=device ) mode, mean, std, vvc = tt_aug(test_data)
N维傅里叶变换#
- monai.data.fft_utils.fftn_centered(im, spatial_dims, is_complex=True)[source]#
基于 Pytorch 的 spatial_dims 维信号 FFT。“centered”意味着此函数会自动处理所需的 ifft 和 fft shift。此函数调用 monai.networks.blocks.fft_utils_t.fftn_centered_t。这等同于基于 numpy.fft.fftn, numpy.fft.fftshift 和 numpy.fft.ifftshift 在 numpy 中进行 ifft。
- 参数:
im (
Union[ndarray,Tensor]) – 图像可以是 1) 实值：2D 空间输入的形状为 (C,H,W)，3D 的形状为 (C,H,W,D)，或 2) 复值：2D 空间数据的形状为 (C,H,W,2)，3D 的形状为 (C,H,W,D,2)。C 是通道数。spatial_dims (
int) – 空间维度数（例如，图像为 2，体数据为 3）is_complex (
bool) – 如果为 True，则输入的 im 的最后一维期望为 2（表示实部和虚部通道）
- 返回类型:
Union[ndarray,Tensor]- 返回:
“out”，它是输出 kspace（im 的傅里叶变换）
示例
import torch im = torch.ones(1,3,3,2) # the last dim belongs to real/imaginary parts # output1 and output2 will be identical output1 = torch.fft.fftn(torch.view_as_complex(torch.fft.ifftshift(im,dim=(-3,-2))), dim=(-2,-1), norm="ortho") output1 = torch.fft.fftshift( torch.view_as_real(output1), dim=(-3,-2) ) output2 = fftn_centered(im, spatial_dims=2, is_complex=True)
- monai.data.fft_utils.ifftn_centered(ksp, spatial_dims, is_complex=True)[source]#
基于 Pytorch 的 spatial_dims 维信号 IFFT。“centered”意味着此函数会自动处理所需的 ifft 和 fft shift。此函数调用 monai.networks.blocks.fft_utils_t.ifftn_centered_t。这等同于基于 numpy.fft.ifftn, numpy.fft.fftshift 和 numpy.fft.ifftshift 在 numpy 中进行 fft。
- 参数:
ksp (
Union[ndarray,Tensor]) – k-space 数据可以是 1) 实值：2D 空间输入的形状为 (C,H,W)，3D 的形状为 (C,H,W,D)，或 2) 复值：2D 空间数据的形状为 (C,H,W,2)，3D 的形状为 (C,H,W,D,2)。C 是通道数。spatial_dims (
int) – 空间维度数（例如，图像为 2，体数据为 3）is_complex (
bool) – 如果为 True，则输入的 ksp 的最后一维期望为 2（表示实部和虚部通道）
- 返回类型:
Union[ndarray,Tensor]- 返回:
“out”，它是输出图像（ksp 的逆傅里叶变换）
示例
import torch ksp = torch.ones(1,3,3,2) # the last dim belongs to real/imaginary parts # output1 and output2 will be identical output1 = torch.fft.ifftn(torch.view_as_complex(torch.fft.ifftshift(ksp,dim=(-3,-2))), dim=(-2,-1), norm="ortho") output1 = torch.fft.fftshift( torch.view_as_real(output1), dim=(-3,-2) ) output2 = ifftn_centered(ksp, spatial_dims=2, is_complex=True)
ITK Torch Bridge#
- monai.data.itk_torch_bridge.get_itk_image_center(image)[source]#
根据 ITK 图像的原点、大小和间距计算其中心。此中心等效于 MONAI 使用的隐式图像中心。
- 参数:
image – ITK 图像。
- 返回:
图像中心，以坐标列表形式表示。
- monai.data.itk_torch_bridge.itk_image_to_metatensor(image, channel_dim=None, dtype=<class 'float'>)[source]#
将 ITK 图像转换为 MetaTensor 对象。
- 参数:
image – 待转换的 ITK 图像。
channel_dim – 输入图像的通道维度，默认为 None。这用于设置元数据中的 original_channel_dim，EnsureChannelFirst 读取此字段。如果为 None，则自动推断 channel_dim。如果输入数组没有通道维度，则此值应为
'no_channel'。dtype – 输出数据类型，默认为 Python 内置的 float。
- 返回:
一个包含数组数据和元数据（ChannelFirst 格式）的 MetaTensor 对象。
- monai.data.itk_torch_bridge.itk_to_monai_affine(image, matrix, translation, center_of_rotation=None, reference_image=None)[source]#
将 ITK 仿射变换矩阵（2D 为 2x2，3D 为 3x3 矩阵和平移向量）转换为 MONAI 仿射变换矩阵。
- 参数:
image – ITK 图像对象。用于提取间距和方向信息。
matrix – 2x2 或 3x3 的 ITK 仿射变换矩阵。
translation – 2 或 3 个元素的 ITK 仿射变换平移向量。
center_of_rotation – 旋转中心。如果提供，将调整仿射变换矩阵以考虑图像中心和旋转中心之间的差异。
reference_image – 矩阵和 translation 相对于其定义的坐标空间。如果未提供，则使用 image 的坐标空间。
- 返回类型:
Tensor- 返回:
一个 4x4 的 MONAI 仿射变换矩阵。
- monai.data.itk_torch_bridge.metatensor_to_itk_image(meta_tensor, channel_dim=0, dtype=<class 'numpy.float32'>, **kwargs)[source]#
将 MetaTensor 对象转换为 ITK 图像。期望 MetaTensor 为 ChannelFirst 格式。
- 参数:
meta_tensor – 待转换的 MetaTensor。
channel_dim – 数据数组的通道维度，默认为
0(Channel-first)。None表示没有通道维度。如果不是None，则用于创建 Vector Image。dtype – 输出数据类型，默认为 np.float32。
kwargs – 附加关键字参数。目前 itk.GetImageFromArray 将从该字典获取
ttype。
- 返回:
ITK 图像。
另请参见：
ITKWriter.create_backend_obj()
- monai.data.itk_torch_bridge.monai_to_itk_affine(image, affine_matrix, center_of_rotation=None)[source]#
将 MONAI 仿射变换矩阵转换为 ITK 仿射变换矩阵（2D 为 2x2，3D 为 3x3 矩阵和平移向量）。另请参见“itk_to_monai_affine”。
- 参数:
image – ITK 图像对象。用于提取间距和方向信息。
affine_matrix – 2D 为 3x3 或 3D 为 4x4 的 MONAI 仿射变换矩阵。
center_of_rotation – 旋转中心。如果提供，将调整仿射变换矩阵以考虑图像中心和旋转中心之间的差异。
- 返回:
ITK 矩阵和平移向量。
元对象#
- class monai.data.meta_obj.MetaObj[source]#
抽象基类，用于存储数据以及任何额外元数据。
这允许通过多重继承来子类化 torch.Tensor 和 np.ndarray。
元数据以字典形式存储。
行为应与扩展类（例如，torch.Tensor 或 np.ndarray）相同，除了扩展的元功能。
信息的复制
对于 c = a + b，如果 a.is_batch 为 False，则辅助数据（例如，元数据）将从第一个 MetaObj 实例复制（对于批处理数据，元数据将进行浅复制以提高效率）。
- property applied_operations: list[dict]#
获取已应用的运算。默认为
[]。- 返回类型:
list[dict]
- copy_meta_from(input_objs, copy_attr=True, keys=None)[source]#
从 MetaObj 或 MetaObj 实例的可迭代对象中复制元数据。
- 参数:
input_objs – 要从中复制数据的 MetaObj 列表。
copy_attr – 是否使用 MetaObj.copy_item 复制每个属性。请注意，如果属性是嵌套列表或字典，则只会进行浅复制。
keys – 要从
input_objs复制的属性键。如果为 None，则复制 input_objs 中的所有键。
- static flatten_meta_objs(*args)[source]#
递归地展平输入并 yield 所有 MetaObj 实例。这意味着对于 torch.add(a, b) 和 torch.stack([a, b])（及其 numpy 等效项），如果 a 和 b 都是 MetaObj 类型，则返回 [a, b]。
- 参数:
args (
Iterable) – 待展平输入的 Iterable。- 返回:
输入中的嵌套 MetaObj 列表。
- property has_pending_operations: bool#
确定是否存在待处理的运算。:rtype:
bool:returns: 如果存在待处理运算则为 True；否则为 False
- property is_batch: bool#
返回对象是否为批次的一部分。
- 返回类型:
bool
- property meta: dict#
获取元数据。默认为
{}。- 返回类型:
dict
- property pending_operations: list[dict]#
获取待处理的运算。默认为
[]。- 返回类型:
list[dict]
元张量#
- class monai.data.MetaTensor(x, affine=None, meta=None, applied_operations=None, *_args, **_kwargs)[source]#
基类：
MetaObj、Tensor继承自 torch.Tensor 和 MetaObj 的类，增加了对元数据的支持。
元数据以字典形式存储。嵌套地，将存储仿射变换矩阵。这应以 torch.Tensor 的形式存在。
行为应与 torch.Tensor 相同，除了扩展的元功能。
信息的复制
对于 c = a + b，如果 a.is_batch 为 False，则辅助数据（例如，元数据）将从第一个 MetaTensor 实例复制（对于批处理数据，元数据将进行浅复制以提高效率）。
示例
import torch from monai.data import MetaTensor t = torch.tensor([1,2,3]) affine = torch.as_tensor([[2,0,0,0], [0,2,0,0], [0,0,2,0], [0,0,0,1]], dtype=torch.float64) meta = {"some": "info"} m = MetaTensor(t, affine=affine, meta=meta) m2 = m + m assert isinstance(m2, MetaTensor) assert m2.meta["some"] == "info" assert torch.all(m2.affine == affine)
注意事项
需要 pytorch 1.9 或更高版本才能完全兼容。
较旧版本的 pytorch (<=1.8)，如果 im 的类型为 MetaTensor，torch.jit.trace(net, im) 可能无法工作。这可以通过 torch.jit.trace(net, im.as_tensor()) 解决。
对于 pytorch < 1.8，可能不支持在进程之间共享 MetaTensor 实例。
对于 pytorch < 1.9，next(iter(meta_tensor)) 返回 torch.Tensor。参见：pytorch/pytorch#54457
如果在构造函数中 affine 不为 None 且 meta 已包含键 affine，将引发警告。
您可以通过 is_batch 属性查询 MetaTensor 是否是一个批次。
对于一批数据，batch[0] 将返回第 0 个图像及其第 0 个元数据。当批次维度非单例时，例如 batch[:, 0]、batch[…, -1] 和 batch[1:3]，则将返回所有（或最后一个示例中的子集）元数据，且 is_batch 将返回 True。
使用此类别创建批次时，请使用 monai.data.DataLoader 而不是 torch.utils.data.DataLoader，因为前者将负责正确地整理元数据。
- __init__(x, affine=None, meta=None, applied_operations=None, *_args, **_kwargs)[source]#
- 参数:
x – MetaTensor 的初始数组。可以是列表、元组、NumPy ndarray、标量或其他类型。
affine – 可选的 4x4 数组。
meta – 元数据的字典。
applied_operations – 之前应用于 MetaTensor 的操作列表，该列表通常由 monai.transforms.TraceableTransform 维护。另请参阅：
monai.transforms.TraceableTransform_args – 附加参数（此构造函数中当前未使用）。
_kwargs – 附加关键字参数（此构造函数中当前未使用）。
注意
如果提供了 meta 字典，则使用它。否则，如果输入张量 x 中存在 meta，则使用它。否则，使用默认值。affine 类似，但它可以来自四个地方，优先级为：affine、meta[“affine”]、x.affine、get_default_affine。
- property affine: Tensor#
获取 affine。默认为
torch.eye(4, dtype=torch.float64)- 返回类型:
Tensor
- property array#
返回
self的 numpy 数组。如果 self 在 cpu 上，则该数组和self共享相同的底层存储。对self（它是 torch.Tensor 的子类）的更改将反映在 ndarray 中，反之亦然。如果self不在 cpu 上，则调用会将其移至 cpu，然后存储不共享。- 获取器：
- 设置器：
- as_dict(key, output_type=<class 'torch.Tensor'>, dtype=None)[source]#
将对象作为字典获取以实现向后兼容。此方法不会对对象进行深拷贝。
- 参数:
key (
str) – 用于存储主要数据的基本键。元数据的键将使用 PostFix 确定。output_type – 主要数据的 torch.Tensor 或 np.ndarray 类型。
dtype – 输出数据的数据类型（dtype）。如果输出类型是 torch.Tensor，则会转换为正确的库类型（例如，np.float32 转换为 torch.float32）。如果留空，则保持不变。
- 返回类型:
dict- 返回:
一个包含三个键的字典，主要数据（存储在 key 下）和元数据。
- astype(dtype, device=None, *_args, **_kwargs)[source]#
转换为
dtype，尽可能共享数据。- 参数:
dtype – dtypes，例如 np.float32, torch.float, “np.float32”, float。
device – 如果 dtype 是 torch 数据类型，则表示设备。
_args – 附加参数（当前未使用）。
_kwargs – 附加关键字参数（当前未使用）。
- 返回:
数据数组实例
- clone(**kwargs)[source]#
返回 MetaTensor 实例的副本。
- 参数:
kwargs – 传递给 torch.clone 的附加关键字参数。
另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.clone.html
- static ensure_torch_and_prune_meta(im, meta, simple_keys=False, pattern=None, sep='.')[source]#
将图像转换为 MetaTensor（当 meta 不为 None 时）。如果 meta 字典中包含 affine，也将其转换为 torch.Tensor。移除任何多余的元数据。
- 参数:
im – 输入图像（np.ndarray 或 torch.Tensor）
meta – 元数据字典。当为 None 时，不跟踪元数据，此方法返回一个 torch.Tensor。
simple_keys – 是否仅保留元数据键的简单子集。
pattern – 与 sep 结合使用，一个用于匹配和修剪元数据（嵌套字典）中键的正则表达式，默认为 None，不删除键。
sep – 与 pattern 结合使用，用于匹配和删除元数据（嵌套字典）中的键。默认为 “.”，另请参阅
monai.transforms.DeleteItemsd。例如，pattern=".*_code$", sep=" "会移除任何以"_code"结尾的 meta 键。
- 返回:
默认情况下，返回 MetaTensor。但是，如果 get_track_meta() 为 False 或 meta=None，则返回 torch.Tensor。
- get_array(output_type=<class 'numpy.ndarray'>, dtype=None, device=None, *_args, **_kwargs)[source]#
返回 output_type 中的新数组，当输出是 numpy 数组时，该数组共享相同的底层存储。对 self 张量的更改将反映在 ndarray 中，反之亦然。
- 参数:
output_type – 输出类型，另请参阅：
monai.utils.convert_data_type()。dtype – 输出数据的数据类型（dtype）。如果输出类型是 torch.Tensor，则会转换为正确的库类型（例如，np.float32 转换为 torch.float32）。如果留空，则保持不变。
device – 如果输出是 torch.Tensor，则选择设备（如果为 None，则不变）。
_args – 当前未使用的参数。
_kwargs – 当前未使用的关键字参数。
- property pixdim#
获取间距
- set_array(src, non_blocking=False, *_args, **_kwargs)[source]#
将 src 中的元素复制到 self 张量中并返回 self。src 张量必须可广播到 self 张量。它可能具有不同的数据类型或位于不同的设备上。
另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.Tensor.copy_.html
- 参数:
src – 要从中复制的源张量。
non_blocking (
bool) – 如果为 True 且此复制发生在 CPU 和 GPU 之间，则复制可能相对于主机异步发生。对于其他情况，此参数无效。_args – 当前未使用的参数。
_kwargs – 当前未使用的关键字参数。
- static update_meta(rets, func, args, kwargs)[source]#
从 MetaTensor.__torch_function__ 的输出更新元数据。
torch.Tensor.__torch_function__ 的输出可以是一个对象或它们的序列。因此，在 MetaTensor.__torch_function__ 中，如果它们不是列表，则将它们转换为列表，然后循环遍历每个元素，根据需要处理元数据。对于每个元素，如果不是 MetaTensor 类型，则无需执行任何操作。
- 参数:
rets (
Sequence) – torch.Tensor.__torch_function__ 的输出，如果在 MetaTensor.__torch_function__ 中它还不是一个 Sequence，则已转换为列表。func – 已应用的 torch 函数。示例可能是 torch.squeeze 或 torch.Tensor.__add__。我们需要此信息，因为如果考虑的是一批数据，元数据需要区别对待。例如，对一批数据的第 0 维度切片（torch.Tensor.__getitem__）的第 i 个元素应返回一个带有第 i 个元数据的第 i 个张量。
args – 传递给 func 的位置参数。
kwargs – 传递给 func 的关键字参数。
- 返回类型:
Sequence- 返回:
一个序列，其元素数量与 rets 相同。对于每个元素，如果输入类型不是 MetaTensor，则不会进行任何修改。如果全局参数已设置为 False（例如，not get_track_meta()），则任何 MetaTensor 都将转换为 torch.Tensor。否则，将根据需要传播元数据（参见
MetaTensor._copy_meta()）。
全玻片图像读取器#
BaseWSIReader#
- class monai.data.BaseWSIReader(level=None, mpp=None, mpp_rtol=0.05, mpp_atol=0.0, power=None, power_rtol=0.05, power_atol=0.0, channel_dim=0, dtype=<class 'numpy.uint8'>, device=None, mode='RGB', **kwargs)[source]#
一个抽象类，定义了从全玻片图像文件中加载图像块的 API。
- 参数:
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
mpp_rtol – 微米/像素分辨率的可接受相对容差。
mpp_atol – 微米/像素分辨率的可接受绝对容差。
power – 提取图像块时的物镜倍数。
power_rtol – 物镜倍数的可接受相对容差。
power_atol – 物镜倍数的可接受绝对容差。
channel_dim – 颜色通道的所需维度。
dtype – 输出图像的数据类型。
device – 放置提取图像块的目标设备。注意，如果设备是“cuda”，即使 dtype 是 numpy，输出也会转换为 torch 张量并发送到 gpu。
mode – 输出图像的颜色模式，例如“RGB”或“RGBA”。
kwargs – 读取器的附加参数
注意 – 只能提供分辨率参数 level、mpp 或 power 中的一个。如果在 get_data 方法中提供了这些参数，它们将覆盖此处提供的值。如果此处或 get_data 中均未提供，将使用 level=0。
此类具体实现的典型用法是
image_reader = MyWSIReader() wsi = image_reader.read(filepath, **kwargs) img_data, meta_data = image_reader.get_data(wsi)
调用 read 将图像文件名转换为全玻片图像对象，
get_data调用获取图像数据和元数据。
此类任何具体实现都需要实现以下方法
read 从给定文件读取全玻片图像对象
get_size 返回给定 wsi 对象在给定层级的全玻片图像大小。
get_level_count 返回全玻片图像中的层级数
_get_patch 从全玻片图像中提取并返回图像块
_get_metadata 提取并返回全玻片图像和特定图像块的元数据。
- get_data(wsi, location=(0, 0), size=None, level=None, mpp=None, power=None, mode=None)[source]#
验证输入，从 WSI 图像中提取图像块并生成元数据。
- 参数:
wsi – 从文件加载的全玻片图像对象或此类对象的列表。
location – (top, left) 元组，表示 level 0 参考框架中的左上角像素。默认为 (0, 0)。
size – (height, width) 元组，表示给定层级 (level) 的图像块大小。如果未提供或为 None，则将其设置为给定层级的完整图像大小。
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
power – 提取图像块时的物镜倍数。
dtype – 输出图像的数据类型。
mode – 输出图像模式，‘RGB’ 或 ‘RGBA’。
- 返回:
- 一个元组，其中第一个元素是图像块 [CxHxW] 或图像块堆栈，
第二个元素是元数据的字典。
注意事项
只能提供分辨率参数 level、mpp 或 power 中的一个。如果未提供任何参数，则使用在类实例化期间设置的默认值。如果此处或类实例化期间均未设置，将使用 level=0。
- abstract get_downsample_ratio(wsi, level)[source]#
返回全玻片图像在给定层级的下采样率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算下采样率的层级号。
- 返回类型:
浮点数
- abstract get_mpp(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算 mpp 的层级号。
- 返回类型:
tuple[float,float]
- abstract get_power(wsi, level)[source]#
返回全玻片图像在给定层级的物镜倍数。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算物镜倍数的层级号。
- 返回类型:
浮点数
- abstract get_size(wsi, level)[source]#
返回全玻片图像在给定层级的大小 (height, width)。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算大小的层级号。
- 返回类型:
tuple[int,int]
WSIReader#
- class monai.data.WSIReader(backend='cucim', level=None, mpp=None, mpp_rtol=0.05, mpp_atol=0.0, power=None, power_rtol=0.05, power_atol=0.0, channel_dim=0, dtype=<class 'numpy.uint8'>, device=None, mode='RGB', **kwargs)[source]#
使用不同的后端库读取全玻片图像并提取图像块
- 参数:
backend – 后端全玻片图像读取库的名称，默认为 cuCIM。
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
mpp_rtol – 微米/像素分辨率的可接受相对容差。
mpp_atol – 微米/像素分辨率的可接受绝对容差。
power – 提取图像块时的物镜倍数。
power_rtol – 物镜倍数的可接受相对容差。
power_atol – 物镜倍数的可接受绝对容差。
channel_dim – 颜色通道的所需维度。默认为 0（通道在前）。
dtype – 输出图像的数据类型。默认为 np.uint8。
device – 放置提取图像块的目标设备。注意，如果设备是“cuda”，即使 dtype 是 numpy，输出也会转换为 torch 张量并发送到 gpu。
mode – 输出图像颜色模式，“RGB” 或 “RGBA”。默认为 “RGB”。
num_workers – 多线程图像加载的工作线程数（仅适用于 cucim 后端）。
kwargs – 传递给后端库的附加参数
注意 – 只能提供分辨率参数 level、mpp 或 power 中的一个。如果在 get_data 方法中提供了这些参数，它们将覆盖此处提供的值。如果此处或 get_data 中均未提供，将使用 level=0。
- get_downsample_ratio(wsi, level)[source]#
返回全玻片图像在给定层级的下采样率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算下采样率的层级号。
- 返回类型:
浮点数
- get_mpp(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算 mpp 的层级号。
- 返回类型:
tuple[float,float]
- get_power(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算物镜倍数的层级号。
- 返回类型:
浮点数
CuCIMWSIReader#
- class monai.data.CuCIMWSIReader(num_workers=0, **kwargs)[source]#
使用 cuCIM 库读取全玻片图像并提取补丁。
- 参数:
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
mpp_rtol – 微米/像素分辨率的可接受相对容差。
mpp_atol – 微米/像素分辨率的可接受绝对容差。
power – 提取图像块时的物镜倍数。
power_rtol – 物镜倍数的可接受相对容差。
power_atol – 物镜倍数的可接受绝对容差。
channel_dim – 颜色通道的所需维度。默认为 0（通道在前）。
dtype – 输出图像的数据类型。默认为 np.uint8。
device – 放置提取图像块的目标设备。注意，如果设备是“cuda”，即使 dtype 是 numpy，输出也会转换为 torch 张量并发送到 gpu。
mode – 输出图像颜色模式，“RGB” 或 “RGBA”。默认为 “RGB”。
num_workers (
int) – 多线程图像加载的工作线程数。kwargs – cucim.CuImage 模块的额外参数：rapidsai/cucim
注意 – 只能提供分辨率参数 level、mpp 或 power 中的一个。如果在 get_data 方法中提供了这些参数，它们将覆盖此处提供的值。如果此处或 get_data 中均未提供，将使用 level=0。
- get_downsample_ratio(wsi, level)[source]#
返回全玻片图像在给定层级的下采样率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算下采样率的层级号。
- 返回类型:
浮点数
- get_mpp(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算 mpp 的层级号。
- 返回类型:
tuple[float,float]
- get_power(wsi, level)[source]#
返回全玻片图像在给定层级的物镜倍数。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算物镜倍数的层级号。
- 返回类型:
浮点数
- get_size(wsi, level)[source]#
返回全玻片图像在给定层级的大小 (height, width)。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算大小的层级号。
- 返回类型:
tuple[int,int]
- read(data, **kwargs)[source]#
从给定文件或文件列表读取全玻片图像对象。
- 参数:
data – 要读取的文件名或文件名列表。
kwargs – 额外参数，用于覆盖现有键的 self.kwargs。更多详细信息请参阅 rapidsai/cucim
- 返回:
全玻片图像对象或此类对象的列表。
OpenSlideWSIReader#
- class monai.data.OpenSlideWSIReader(**kwargs)[source]#
使用 OpenSlide 库读取全玻片图像并提取补丁。
- 参数:
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
mpp_rtol – 微米/像素分辨率的可接受相对容差。
mpp_atol – 微米/像素分辨率的可接受绝对容差。
power – 提取图像块时的物镜倍数。
power_rtol – 物镜倍数的可接受相对容差。
power_atol – 物镜倍数的可接受绝对容差。
channel_dim – 颜色通道的所需维度。默认为 0（通道在前）。
dtype – 输出图像的数据类型。默认为 np.uint8。
device – 放置提取图像块的目标设备。注意，如果设备是“cuda”，即使 dtype 是 numpy，输出也会转换为 torch 张量并发送到 gpu。
mode – 输出图像颜色模式，“RGB” 或 “RGBA”。默认为 “RGB”。
kwargs – openslide.OpenSlide 模块的额外参数。
注意 – 只能提供分辨率参数 level、mpp 或 power 中的一个。如果在 get_data 方法中提供了这些参数，它们将覆盖此处提供的值。如果此处或 get_data 中均未提供，将使用 level=0。
- get_downsample_ratio(wsi, level)[source]#
返回全玻片图像在给定层级的下采样率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算下采样率的层级号。
- 返回类型:
浮点数
- get_mpp(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算 mpp 的层级号。
- 返回类型:
tuple[float,float]
- get_power(wsi, level)[source]#
返回全玻片图像在给定层级的物镜倍数。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算物镜倍数的层级号。
- 返回类型:
浮点数
TiffFileWSIReader#
- class monai.data.TiffFileWSIReader(**kwargs)[source]#
使用 TiffFile 库读取全玻片图像并提取补丁。
- 参数:
level – 提取图像块的全玻片图像层级。
mpp – 提取图像块时的分辨率（微米/像素）。
mpp_rtol – 微米/像素分辨率的可接受相对容差。
mpp_atol – 微米/像素分辨率的可接受绝对容差。
channel_dim – 颜色通道的所需维度。默认为 0（通道在前）。
dtype – 输出图像的数据类型。默认为 np.uint8。
device – 放置提取图像块的目标设备。注意，如果设备是“cuda”，即使 dtype 是 numpy，输出也会转换为 torch 张量并发送到 gpu。
mode – 输出图像颜色模式，“RGB” 或 “RGBA”。默认为 “RGB”。
kwargs – tifffile.TiffFile 模块的额外参数。
注意 –
无法通过 TiffFile 后端获取物镜倍率。
- 分辨率参数中只能提供 level 或 mpp 中的一个。
如果在 get_data 方法中提供了这些参数，它们将覆盖此处提供的值。如果此处或 get_data 中均未提供，则将使用 level=0。
- get_downsample_ratio(wsi, level)[source]#
返回全玻片图像在给定层级的下采样率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算下采样率的层级号。
- 返回类型:
浮点数
- get_mpp(wsi, level)[source]#
返回全玻片图像在给定层级的微米/像素分辨率。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算 mpp 的层级号。
- 返回类型:
tuple[float,float]
- get_power(wsi, level)[source]#
返回全玻片图像在给定层级的物镜倍数。
- 参数:
wsi – 从文件加载的全玻片图像对象。
level (
int) – 计算物镜倍数的层级号。
- 返回类型:
浮点数
全玻片图像数据集#
PatchWSIDataset#
- class monai.data.PatchWSIDataset(data, patch_size=None, patch_level=None, transform=None, include_label=True, center_location=True, additional_meta_keys=None, reader='cuCIM', **kwargs)[source]#
此数据集从全玻片图像中提取补丁（不加载整个图像），它还读取每个补丁的标签，并提供每个补丁及其相关的类别标签。
- 参数:
data – 输入样本列表，包括图像、位置和标签（更多详细信息请参见下面的注意）。
patch_size – 从全玻片图像中提取的补丁大小。
patch_level – 提取补丁所处的级别（默认为 0）。
transform – 对输入数据执行的转换。
include_label – 是否加载并将标签包含在输出中
center_location – 输入位置信息是否是补丁中心的位置
additional_meta_keys – 要从输入数据复制到输出元数据中的项目的键列表
reader –
用于加载全玻片图像的模块。如果 reader 是
一个字符串，它定义了 monai.data.WSIReader 的后端。默认为 cuCIM。
一个类（继承自 BaseWSIReader），它将被初始化并设置为 wsi_reader。
一个继承自 BaseWSIReader 的类的实例，它将被设置为 wsi_reader。
kwargs – 传递给 WSIReader 或提供的全玻片读取器类的额外参数
- 返回:
加载的图像（MetaTensor 格式）以及标签（如果请求）的字典。{“image”: MetaTensor, “label”: torch.Tensor}
- 返回类型:
dict
注意
输入数据的形式例如如下
[ {"image": "path/to/image1.tiff", "location": [200, 500], "label": 0}, {"image": "path/to/image2.tiff", "location": [100, 700], "patch_size": [20, 20], "patch_level": 2, "label": 1} ]
MaskedPatchWSIDataset#
- class monai.data.MaskedPatchWSIDataset(data, patch_size=None, patch_level=None, mask_level=7, transform=None, include_label=False, center_location=False, additional_meta_keys=(mask_location, name), reader='cuCIM', **kwargs)[source]#
此数据集从前景掩码在给定级别不为零的位置提取全玻片图像的补丁。
- 参数:
data – 输入样本列表，包括图像、位置和标签（更多详细信息请参见下面的注意）。
patch_size – 从全玻片图像中提取的补丁大小。
patch_level – 提取补丁所处的级别（默认为 0）。
mask_level – 创建掩码的分辨率级别。
transform – 对输入数据执行的转换。
include_label – 是否加载并将标签包含在输出中
center_location – 输入位置信息是否是补丁中心的位置
additional_meta_keys – 要从输入数据复制到输出元数据中的项目的键列表
reader –
用于加载全玻片图像的模块。默认为 cuCIM。如果 reader 是
一个字符串，它定义了 monai.data.WSIReader 的后端。
一个类（继承自 BaseWSIReader），它将被初始化并设置为 wsi_reader，
一个继承自 BaseWSIReader 的类的实例，它将被设置为 wsi_reader。
kwargs – 传递给 WSIReader 或提供的全玻片读取器类的额外参数
注意
输入数据的形式例如如下
[ {"image": "path/to/image1.tiff"}, {"image": "path/to/image2.tiff", "size": [20, 20], "level": 2} ]
SlidingPatchWSIDataset#
- class monai.data.SlidingPatchWSIDataset(data, patch_size=None, patch_level=None, mask_level=0, overlap=0.0, offset=(0, 0), offset_limits=None, transform=None, include_label=False, center_location=False, additional_meta_keys=(mask_location, mask_size, num_patches), reader='cuCIM', seed=0, **kwargs)[source]#
此数据集以滑动窗口方式从全玻片图像中提取补丁（不加载整个图像）。它还读取每个补丁的标签，并提供每个补丁及其相关的类别标签。
- 参数:
data – 输入样本列表，包括图像、位置和标签（更多详细信息请参见下面的注意）。
patch_size – 从全玻片图像中提取的补丁大小。
patch_level – 提取补丁所处的级别（默认为 0）。
mask_level – 创建掩码/映射的分辨率级别（例如用于 ProbMapProducer）。
overlap – 相邻 patch 在每个维度上的重叠量（一个介于 0.0 和 1.0 之间的值）。如果只给一个浮点数，它将应用于所有维度。默认为 0.0。
offset – 提取补丁的图像偏移量（左上角补丁的起始位置）。
offset_limits – 如果 offset 设置为“random”，则是一个整数元组，定义所有维度的随机偏移量的下限和上限；或者是一个元组列表，定义每个维度的限制。
transform – 对输入数据执行的转换。
include_label – 是否加载并将标签包含在输出中
center_location – 输入位置信息是否是补丁中心的位置
additional_meta_keys – 要从输入数据复制到输出元数据中的项目的键列表
reader –
用于加载全玻片图像的模块。默认为 cuCIM。如果 reader 是
一个字符串，它定义了 monai.data.WSIReader 的后端。
一个类（继承自 BaseWSIReader），它将被初始化并设置为 wsi_reader，
一个继承自 BaseWSIReader 的类的实例，它将被设置为 wsi_reader。
seed – 用于随机生成偏移量的随机种子。默认为 0。
kwargs – 传递给 WSIReader 或提供的全玻片读取器类的额外参数
注意
输入数据的形式例如如下
[ {"image": "path/to/image1.tiff"}, {"image": "path/to/image2.tiff", "patch_size": [20, 20], "patch_level": 2} ]
与 MaskedPatchWSIDataset 不同，此数据集不过滤任何补丁。
边界框#
此实用模块主要支持具有几种不同参数化和相互转换方法的矩形边界框。它提供对框顶点在“规范排序”中的空间坐标的可靠访问：对于 2D 是 [xmin, ymin, xmax, ymax]，对于 3D 是 [xmin, ymin, zmin, xmax, ymax, zmax]。我们目前将此排序定义为 monai.data.box_utils.StandardMode，其余的检测管道主要假定框处于 StandardMode 中。
- class monai.data.box_utils.BoxMode[source]#
BoxMode的抽象类。BoxMode是一个可调用对象，用于转换boxes的框模式，boxes是 Nx4 (2D) 或 Nx6 (3D) 的 torch tensor 或 ndarray。BoxMode有几个子类，代表不同的框模式，包括CornerCornerModeTypeA：表示 2D 的 [xmin, ymin, xmax, ymax] 和 3D 的 [xmin, ymin, zmin, xmax, ymax, zmax]
CornerCornerModeTypeB：表示 2D 的 [xmin, xmax, ymin, ymax] 和 3D 的 [xmin, xmax, ymin, ymax, zmin, zmax]
CornerCornerModeTypeC：表示 2D 的 [xmin, ymin, xmax, ymax] 和 3D 的 [xmin, ymin, xmax, ymax, zmin, zmax]
CornerSizeMode：表示 2D 的 [xmin, ymin, xsize, ysize] 和 3D 的 [xmin, ymin, zmin, xsize, ysize, zsize]
CenterSizeMode：表示 2D 的 [xcenter, ycenter, xsize, ysize] 和 3D 的 [xcenter, ycenter, zcenter, xsize, ysize, zsize]
我们目前将
StandardMode= CornerCornerModeTypeA，MONAI 检测管道主要假定boxes处于StandardMode中。实现时应注意
记住定义类变量
name，一个将spatial_dims映射到 BoxModeName 的字典。boxes_to_corners() 和 corners_to_boxes() 不应修改输入。
- abstract boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- abstract corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- class monai.data.box_utils.CenterSizeMode[source]#
BoxMode的子类。也表示为“ccwh”或“cccwhd”，格式为 [xmin, ymin, xsize, ysize] 或 [xmin, ymin, zmin, xsize, ysize, zsize]。
示例
CenterSizeMode.get_name(spatial_dims=2) # will return "ccwh" CenterSizeMode.get_name(spatial_dims=3) # will return "cccwhd"
- boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- class monai.data.box_utils.CornerCornerModeTypeA[source]#
BoxMode的子类。也表示为“xyxy”或“xyzxyz”，格式为 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax]。
示例
CornerCornerModeTypeA.get_name(spatial_dims=2) # will return "xyxy" CornerCornerModeTypeA.get_name(spatial_dims=3) # will return "xyzxyz"
- boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- class monai.data.box_utils.CornerCornerModeTypeB[source]#
BoxMode的子类。也表示为“xxyy”或“xxyyzz”，格式为 [xmin, xmax, ymin, ymax] 或 [xmin, xmax, ymin, ymax, zmin, zmax]。
示例
CornerCornerModeTypeB.get_name(spatial_dims=2) # will return "xxyy" CornerCornerModeTypeB.get_name(spatial_dims=3) # will return "xxyyzz"
- boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- class monai.data.box_utils.CornerCornerModeTypeC[source]#
BoxMode的子类。也表示为“xyxy”或“xyxyzz”，格式为 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, xmax, ymax, zmin, zmax]。
示例
CornerCornerModeTypeC.get_name(spatial_dims=2) # will return "xyxy" CornerCornerModeTypeC.get_name(spatial_dims=3) # will return "xyxyzz"
- boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- class monai.data.box_utils.CornerSizeMode[source]#
BoxMode的子类。也表示为“xywh”或“xyzwhd”，格式为 [xmin, ymin, xsize, ysize] 或 [xmin, ymin, zmin, xsize, ysize, zsize]。
示例
CornerSizeMode.get_name(spatial_dims=2) # will return "xywh" CornerSizeMode.get_name(spatial_dims=3) # will return "xyzwhd"
- boxes_to_corners(boxes)[source]#
将当前模式的边界框转换为角点。
- 参数:
boxes (
Tensor) – 边界框，Nx4 或 Nx6 torch tensor- 返回:
框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)
- 返回类型:
元组
示例
boxes = torch.ones(10,6) boxmode = BoxMode() boxmode.boxes_to_corners(boxes) # will return a 6-element tuple, each element is a 10x1 tensor
- corners_to_boxes(corners)[source]#
将给定的框角点转换为当前模式的边界框。
- 参数:
corners (
Sequence) – 框的角点，4 元素或 6 元素元组，每个元素是一个 Nx1 torch tensor。它表示 (xmin, ymin, xmax, ymax) 或 (xmin, ymin, zmin, xmax, ymax, zmax)- 返回:
边界框，Nx4 或 Nx6 torch tensor
- 返回类型:
Tensor
示例
corners = (torch.ones(10,1), torch.ones(10,1), torch.ones(10,1), torch.ones(10,1)) boxmode = BoxMode() boxmode.corners_to_boxes(corners) # will return a 10x4 tensor
- monai.data.box_utils.batched_nms(boxes, scores, labels, nms_thresh, max_proposals=-1, box_overlap_metric=<function box_iou>)[source]#
批量执行非极大值抑制。每个标签值对应一个类别，NMS 不会在不同类别之间应用。
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModescores (
Union[ndarray,Tensor]) – 框的预测得分，大小为 (N,)。此函数保留得分较高的框。labels (
Union[ndarray,Tensor]) – 每个框的类别索引，大小为 (N,)，值范围为 (0, num_classes)nms_thresh (
float) – NMS 阈值。丢弃所有框重叠度 > nms_thresh 的重叠框。max_proposals (
int) – 保留的最大框数。如果max_proposals= -1，则保留的框数没有限制。box_overlap_metric (
Callable) – 计算框之间重叠度的度量。
- 返回类型:
Union[ndarray,Tensor]- 返回:
NMS 后保留的
boxes索引。
- monai.data.box_utils.box_area(boxes)[source]#
此函数计算每个框的面积 (2D) 或体积 (3D)。不建议使用半精度，因为它可能导致溢出，尤其是对于 3D 图像。
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardMode- 返回类型:
Union[ndarray,Tensor]- 返回:
框的面积 (2D) 或体积 (3D)，大小为 (N,)。
示例
boxes = torch.ones(10,6) # we do computation with torch.float32 to avoid overflow compute_dtype = torch.float32 area = box_area(boxes=boxes.to(dtype=compute_dtype)) # torch.float32, size of (10,)
- monai.data.box_utils.box_centers(boxes)[source]#
计算框的中心点
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardMode- 返回类型:
Union[ndarray,Tensor]- 返回:
中心点，大小为 (N, spatial_dims)
- monai.data.box_utils.box_giou(boxes1, boxes2)[source]#
计算两组框的广义交并比 (GIoU)。两个输入可以具有不同的形状，函数返回一个 NxM 矩阵（与 box_pair_giou() 相反，后者要求输入具有相同的形状并返回
N个值）。- 参数:
boxes1 (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModeboxes2 (
Union[ndarray,Tensor]) – 边界框，Mx4 或 Mx6 的 torch tensor 或 ndarray。假定框模式为StandardMode
- 返回类型:
Union[ndarray,Tensor]- 返回:
GIoU，大小为 (N,M)，数据类型与
boxes1相同
- monai.data.box_utils.box_iou(boxes1, boxes2)[source]#
计算两组框的交并比 (IoU)。
- 参数:
boxes1 (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModeboxes2 (
Union[ndarray,Tensor]) – 边界框，Mx4 或 Mx6 的 torch tensor 或 ndarray。假定框模式为StandardMode
- 返回类型:
Union[ndarray,Tensor]- 返回:
IoU，大小为 (N,M)，数据类型与
boxes1相同
- monai.data.box_utils.box_pair_giou(boxes1, boxes2)[source]#
计算一对框的广义交并比 (GIoU)。两个输入应该具有相同的形状，函数返回一个 (N,) 数组（与 box_giou() 相反，后者不要求输入具有相同的形状并返回
NxM矩阵）。- 参数:
boxes1 (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModeboxes2 (
Union[ndarray,Tensor]) – 边界框，形状与 boxes1 相同。假定框模式为StandardMode
- 返回类型:
Union[ndarray,Tensor]- 返回:
配对的 GIoU，大小为 (N,)，数据类型与
boxes1相同
- monai.data.box_utils.boxes_center_distance(boxes1, boxes2, euclidean=True)[source]#
两组框的中心点之间的距离
- 参数:
boxes1 (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModeboxes2 (
Union[ndarray,Tensor]) – 边界框，Mx4 或 Mx6 的 torch tensor 或 ndarray。假定框模式为StandardModeeuclidean (
bool) – 计算欧几里德距离，否则使用 l1 距离
- 返回类型:
tuple[Union[ndarray,Tensor],Union[ndarray,Tensor],Union[ndarray,Tensor]]- 返回:
boxes1 和 boxes2 中每个元素的成对距离，大小为 (N,M)，数据类型与
boxes1相同。boxes1 的中心点，大小为 (N,spatial_dims)，数据类型与
boxes1相同。boxes2 的中心点，大小为 (M,spatial_dims)，数据类型与
boxes1相同。
- monai.data.box_utils.centers_in_boxes(centers, boxes, eps=0.01)[source]#
检查哪些中心点在框内
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardMode。centers (
Union[ndarray,Tensor]) – 中心点，Nx2 或 Nx3 的 torch tensor 或 ndarray。eps (
float) – 到框边界的最小距离。
- 返回类型:
Union[ndarray,Tensor]- 返回:
布尔数组，指示哪些中心点在框内，大小为 (N,)。
- monai.data.box_utils.clip_boxes_to_image(boxes, spatial_size, remove_empty=True)[source]#
此函数裁剪
boxes以确保边界框在图像范围内。- 参数:
boxes – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为
StandardModespatial_size – 框所附图像的空间大小。len(spatial_size) 应在 [2, 3] 范围内。
remove_empty – 是否移除实际为空的框
- 返回:
裁剪后的框，boxes[keep]，不与原始框共享内存
keep，表示当remove_empty=True时，boxes中的每个框是否被保留。
- monai.data.box_utils.convert_box_mode(boxes, src_mode=None, dst_mode=None)[source]#
此函数将 src_mode 中的框转换为 dst_mode。
- 参数:
boxes – 源边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。
src_mode – 源框模式。如果未给出，此函数将假定为
StandardMode()。它与 get_boxmode() 中的mode格式相同。dst_mode – 目标框模式。如果未给出，此函数将假定为
StandardMode()。它与 get_boxmode() 中的mode格式相同。
- 返回:
具有目标模式的边界框，数据类型与
boxes相同，不与boxes共享内存
示例
boxes = torch.ones(10,4) # The following three lines are equivalent # They convert boxes with format [xmin, ymin, xmax, ymax] to [xcenter, ycenter, xsize, ysize]. convert_box_mode(boxes=boxes, src_mode="xyxy", dst_mode="ccwh") convert_box_mode(boxes=boxes, src_mode="xyxy", dst_mode=monai.data.box_utils.CenterSizeMode) convert_box_mode(boxes=boxes, src_mode="xyxy", dst_mode=monai.data.box_utils.CenterSizeMode())
- monai.data.box_utils.convert_box_to_standard_mode(boxes, mode=None)[source]#
将给定的框转换为标准模式。标准模式是“xyxy”或“xyzxyz”，表示框格式为 [xmin, ymin, xmax, ymax] 或 [xmin, ymin, zmin, xmax, ymax, zmax]。
- 参数:
boxes – 源边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。
mode – 源框模式。如果未给出，此函数将假定为
StandardMode()。它与 get_boxmode() 中的mode格式相同。
- 返回:
具有标准模式的边界框，数据类型与
boxes相同，不与boxes共享内存
示例
boxes = torch.ones(10,6) # The following two lines are equivalent # They convert boxes with format [xmin, xmax, ymin, ymax, zmin, zmax] to [xmin, ymin, zmin, xmax, ymax, zmax] convert_box_to_standard_mode(boxes=boxes, mode="xxyyzz") convert_box_mode(boxes=boxes, src_mode="xxyyzz", dst_mode="xyzxyz")
- monai.data.box_utils.get_boxmode(mode=None, *args, **kwargs)[source]#
此函数根据框模式表示返回一个 BoxMode 对象
- 参数:
mode – 框模式的表示。如果未给出，此函数将假定为
StandardMode()。
注意
StandardMode= CornerCornerModeTypeA，也表示为 2D 的“xyxy”和 3D 的“xyzxyz”。- 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 类：从 BoxMode 的子类中选择，例如，
CornerCornerModeTypeA：等同于“xyxy”或“xyzxyz”
CornerCornerModeTypeB：等同于“xxyy”或“xxyyzz”
CornerCornerModeTypeC：等同于“xyxy”或“xyxyzz”
CornerSizeMode：等同于“xywh”或“xyzwhd”
CenterSizeMode：等同于“ccwh”或“cccwhd”
- BoxMode 对象：从 BoxMode 的子类中选择，例如，
CornerCornerModeTypeA()：等同于“xyxy”或“xyzxyz”
CornerCornerModeTypeB()：等同于“xxyy”或“xxyyzz”
CornerCornerModeTypeC()：等同于“xyxy”或“xyxyzz”
CornerSizeMode()：等同于“xywh”或“xyzwhd”
CenterSizeMode()：等同于“ccwh”或“cccwhd”
None：将假定模式为
StandardMode()
- 返回:
BoxMode 对象
示例
mode = "xyzxyz" get_boxmode(mode) # will return CornerCornerModeTypeA()
- monai.data.box_utils.get_spatial_dims(boxes=None, points=None, corners=None, spatial_size=None)[source]#
获取给定设置的空间维度并检查其有效性。允许输入缺失。但至少应提供一个输入值。如果多个输入的维度不匹配，则会引发 ValueError。
- 参数:
boxes – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray
points – 点坐标，[x, y] 或 [x, y, z]，Nx2 或 Nx3 的 torch tensor 或 ndarray
corners – 框的角点，4 元素或 6 元素元组，每个元素是 Nx1 的 torch tensor 或 ndarray
spatial_size – 框所附图像的空间大小。len(spatial_size) 应在 [2, 3] 范围内。
- 返回:
spatial_dims，边界框的空间维度数。
- 返回类型:
int
示例
boxes = torch.ones(10,6) get_spatial_dims(boxes, spatial_size=[100,200,200]) # will return 3 get_spatial_dims(boxes, spatial_size=[100,200]) # will raise ValueError get_spatial_dims(boxes) # will return 3
- monai.data.box_utils.is_valid_box_values(boxes)[source]#
此函数检查框的大小是否非负。
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardMode- 返回类型:
bool- 返回:
是否
boxes有效
- monai.data.box_utils.non_max_suppression(boxes, scores, nms_thresh, max_proposals=-1, box_overlap_metric=<function box_iou>)[source]#
非极大值抑制 (NMS)。
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为StandardModescores (
Union[ndarray,Tensor]) – 框的预测得分，大小为 (N,)。此函数保留得分较高的框。nms_thresh (
float) – NMS 阈值。丢弃所有框重叠度 > nms_thresh 的重叠框。max_proposals (
int) – 保留的最大框数。如果max_proposals= -1，则保留的框数没有限制。box_overlap_metric (
Callable) – 计算框之间重叠度的度量。
- 返回类型:
Union[ndarray,Tensor]- 返回:
NMS 后保留的
boxes索引。
示例
boxes = torch.ones(10,6) scores = torch.ones(10) keep = non_max_suppression(boxes, scores, num_thresh=0.1) boxes_after_nms = boxes[keep]
- monai.data.box_utils.spatial_crop_boxes(boxes, roi_start, roi_end, remove_empty=True)[source]#
当相应的图像被裁剪到给定的 ROI 时，此函数生成新的框。当
remove_empty=True时，它确保边界框在新裁剪图像范围内。- 参数:
boxes – 边界框，Nx4 或 Nx6 的 torch tensor 或 ndarray。假定框模式为
StandardModeroi_start – 裁剪 ROI 起始处的体素坐标，允许负值。
roi_end – 裁剪 ROI 结束处的体素坐标，允许负值。
remove_empty – 是否移除实际为空的框
- 返回:
裁剪后的框，boxes[keep]，不与原始框共享内存
keep，表示当remove_empty=True时，boxes中的每个框是否被保留。
- monai.data.box_utils.standardize_empty_box(boxes, spatial_dims)[source]#
当框为空时，此函数将其标准化为 (0,4) 或 (0,6) 的形状。
- 参数:
boxes (
Union[ndarray,Tensor]) – 边界框，Nx4 或 Nx6 或空的 torch tensor 或 ndarrayspatial_dims (
int) – 边界框的空间维度数。
- 返回类型:
Union[ndarray,Tensor]- 返回:
形状为 (N,4) 或 (N,6) 的边界框，N 可以为 0。
示例
boxes = torch.ones(0,) standardize_empty_box(boxes, 3)
视频数据集#
VideoDataset#
VideoFileDataset#
CameraDataset#
- class monai.data.video_dataset.CameraDataset(video_source, transform=None, max_num_frames=None, color_order=RGB, multiprocessing=False, channel_dim=0)[source]#
从捕获设备（例如网络摄像头）创建的视频数据集。
此类要求安装 OpenCV。
- 参数:
video_source – 捕获设备的索引。get_num_devices 可用于确定可能的设备。
transform – 应用于每个帧的转换。
max_num_frames – 迭代的最大帧数。如果传递 None，则数据集将无限迭代。
- 抛出:
RuntimeError – 未安装 OpenCV。