工具#

配置#

class monai.config.deviceconfig.IgniteInfo(*args, **kwargs)[source]#: 已废弃的 IgniteInfo 枚举导入，该枚举已移至 monai.utils.enums.IgniteInfo。

monai.config.deviceconfig.get_system_info()[source]#

获取系统信息作为有序字典。

返回类型:: OrderedDict

monai.config.deviceconfig.print_config(file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#

将包版本打印到 file。

参数:: file – print() 文本流文件。默认为 sys.stdout。

monai.config.deviceconfig.print_debug_info(file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#

打印配置（已安装的依赖项等）和系统信息，用于调试。

参数:: file (TextIO) – print() 文本流文件。默认为 sys.stdout。
返回类型:: None

monai.config.deviceconfig.print_gpu_info(file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#

将 GPU 信息打印到 file。

参数:: file (TextIO) – print() 文本流文件。默认为 sys.stdout。
返回类型:: None

monai.config.deviceconfig.print_system_info(file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#

将系统信息打印到 file。需要可选库 psutil。

参数:: file (TextIO) – print() 文本流文件。默认为 sys.stdout。
返回类型:: None

模块 utils#

exception monai.utils.module.InvalidPyTorchVersionError(required_version, name)[source]#: 当调用的函数或方法需要比已安装版本更新的 PyTorch 版本时引发。

exception monai.utils.module.OptionalImportError[source]#: 无法从可选依赖项导入 API。

monai.utils.module.damerau_levenshtein_distance(s1, s2)[source]#

计算两个字符串的 Damerau–Levenshtein 距离用于拼写校正。 https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance

返回类型:: int

monai.utils.module.exact_version(the_module, version_str='', *_args)[source]#

如果模块的 __version__ 与 version_str 匹配，则返回 True。

返回类型:: bool

monai.utils.module.get_full_type_name(typeobj)[source]#: 获取类或对象类型的完整路径名称的工具。

monai.utils.module.get_package_version(dep_name, default='NOT INSTALLED or UNKNOWN VERSION.')[source]#: 尝试加载包并获取版本。如果未找到，则返回 default。

monai.utils.module.get_torch_version_tuple()#

返回:: 表示 PyTorch 主要/次要版本的整数元组。

monai.utils.module.instantiate(__path, __mode, **kwargs)[source]#

从由 _path 表示的类或函数创建对象实例或调用可调用对象。kwargs 将作为类构造函数或函数的输入参数的一部分。目标组件必须是类或函数，否则直接返回该组件。

参数:

__path (str) – 如果提供字符串，则将其解释为目标类或函数组件的完整路径。如果提供可调用对象，则对于 __mode="default"，将调用并返回 __path(**kwargs)。对于 __mode="callable"，将返回可调用对象作为 __path，或者如果提供了 kwargs，则返回 functools.partial(__path, **kwargs) 以供将来调用。
__mode (str) –
用于调用由 __path 表示的（可调用）component 的操作模式
- "default": 返回 component(**kwargs)
- "callable": 返回 component，或者如果提供了 kwargs，则返回 functools.partial(component, **kwargs)
- "debug": 返回 pdb.runcall(component, **kwargs)
kwargs (Any) – 表示由 __path 可调用对象的关键字参数。

返回类型:

Any

monai.utils.module.look_up_option(opt_str, supported, default='no_default', print_all_options=True)[source]#

在支持的集合中查找选项并返回匹配项。可能会引发 ValueError，并可能给出最接近匹配项的猜测。

参数:

opt_str – 要查找的选项字符串或枚举。
supported – 支持的选项集合，可以是 list、tuple、set、dict 或 Enum。
default – 如果给定，则当未找到 opt_str 时，此方法将返回 default，而不是引发 ValueError。否则，默认为 “no_default”，以便该方法可能引发 ValueError。
print_all_options – 未找到 opt_str 时是否打印所有可用选项。默认为 True。

示例

from enum import Enum
from monai.utils import look_up_option
class Color(Enum):
    RED = "red"
    BLUE = "blue"
look_up_option("red", Color)  # <Color.RED: 'red'>
look_up_option(Color.RED, Color)  # <Color.RED: 'red'>
look_up_option("read", Color)
# ValueError: By 'read', did you mean 'red'?
# 'read' is not a valid option.
# Available options are {'blue', 'red'}.
look_up_option("red", {"red", "blue"})  # "red"

改编自 NifTK/NiftyNet

monai.utils.module.min_version(the_module, min_version_str='', *_args)[source]#

将版本字符串转换为整数元组并进行比较。

如果模块版本大于或等于 'min_version'，则返回 True。当未提供 min_version_str 时，始终返回 True。

返回类型:: bool

monai.utils.module.optional_import(module, version='', version_checker=<function min_version>, name='', descriptor='{}', version_args=None, allow_namespace_pkg=False, as_type='default')[source]#

导入由 module 字符串指定的可选模块。所有导入相关的异常都将存储起来，并在尝试使用导入失败的模块时延迟引发异常。

参数:

module (str) – 要导入的模块名称。
version (str) – 由 version_checker 使用的版本字符串。
version_checker (Callable[…, bool]) – 用于检查模块版本的可调用对象，默认为 monai.utils.min_version。
name (str) – 要从导入的模块中导入的非模块属性（例如方法/类）。
descriptor (str) – 使用未导入模块时最终错误消息的格式字符串。
version_args (Optional[Any]) – 传递给版本检查器的附加参数。
allow_namespace_pkg (bool) – 是否允许导入命名空间包。默认为 False。
as_type (str) – 在某些情况下，可选导入的对象被用作基类或装饰器，应相应地引发异常。当前支持的值包括 “default”（调用一次以引发异常）、“decorator”（调用构造函数并在第二次调用时引发异常），以及任何其他值将返回一个可作为基类使用的惰性类（调用构造函数时引发异常）。

返回类型:

tuple[Any, bool]

返回:

导入的模块和一个布尔标志，指示导入是否成功。

示例

>>> torch, flag = optional_import('torch', '1.1')
>>> print(torch, flag)
<module 'torch' from 'python/lib/python3.6/site-packages/torch/__init__.py'> True

>>> the_module, flag = optional_import('unknown_module')
>>> print(flag)
False
>>> the_module.method  # trying to access a module which is not imported
OptionalImportError: import unknown_module (No module named 'unknown_module').

>>> torch, flag = optional_import('torch', '42', exact_version)
>>> torch.nn  # trying to access a module for which there isn't a proper version imported
OptionalImportError: import torch (requires version '42' by 'exact_version').

>>> conv, flag = optional_import('torch.nn.functional', '1.0', name='conv1d')
>>> print(conv)
<built-in method conv1d of type object at 0x11a49eac0>

>>> conv, flag = optional_import('torch.nn.functional', '42', name='conv1d')
>>> conv()  # trying to use a function from the not successfully imported module (due to unmatched version)
OptionalImportError: from torch.nn.functional import conv1d (requires version '42' by 'min_version').

monai.utils.module.pytorch_after(major, minor, patch=0, current_ver_string=None)#

计算当前 PyTorch 版本是否晚于或等于指定版本。当前系统 PyTorch 版本由 torch.__version__ 或系统环境变量 PYTORCH_VER 确定。

参数:

major – 要比较的主要版本号
minor – 要比较的次要版本号
patch – 要比较的补丁版本号
current_ver_string – 如果为 None，将使用 torch.__version__。

返回:

如果当前 PyTorch 版本大于或等于指定版本，则为 True。

monai.utils.module.require_pkg(pkg_name, version='', version_checker=<function min_version>, raise_error=True)[source]#

用于检查所需包是否安装的装饰器函数。

参数:

pkg_name (str) – 所需的包名称，例如：“itk”、“nibabel”等。
version (str) – 由 version_checker 使用的所需版本字符串。
version_checker (Callable[…, bool]) – 用于检查模块版本的可调用对象，默认为 monai.utils.min_version。
raise_error (bool) – 如果为 True，则在所需包未安装或版本不匹配要求时引发 OptionalImportError 错误；如果为 False，则以警告形式打印错误。

返回类型:

Callable

monai.utils.module.version_geq(lhs, rhs)[source]#

如果版本 lhs 晚于或等于 rhs，则返回 True。

参数:

lhs (str) – 要与 rhs 比较的版本名称，如果晚于或等于 rhs 则返回 True。
rhs (str) – 要与 lhs 比较的版本名称，如果早于或等于 lhs 则返回 True。

返回类型:

bool

monai.utils.module.version_leq(lhs, rhs)[source]#

如果版本 lhs 早于或等于 rhs，则返回 True。

参数:

lhs (str) – 要与 rhs 比较的版本名称，如果早于或等于 rhs 则返回 True。
rhs (str) – 要与 lhs 比较的版本名称，如果晚于或等于 lhs 则返回 True。

返回类型:

bool

杂项#

class monai.utils.misc.ConvertUnits(input_unit, target_unit)[source]#

将值从输入单位转换为目标单位

参数:

input_unit (str) – 输入数量的单位
target_unit (str) – 目标数量的单位

class monai.utils.misc.ImageMetaKey[source]#: 图像元数据头中的常用键名

class monai.utils.misc.MONAIEnvVars[source]#: MONAI 使用的环境变量。

monai.utils.misc.check_key_duplicates(ordered_pairs)[source]#

检查 ordered_pairs 序列中是否存在重复的键。如果存在，它将记录警告或引发 ValueError（如果由环境变量 MONAI_FAIL_ON_DUPLICATE_CONFIG==1 配置）。

否则，返回由该序列创建的字典。

满足 json.load 中 object_pairs_hook 的格式要求。

参数:: ordered_pairs (Sequence[tuple[Any, Any]]) – (键, 值) 对的序列
返回类型:: dict[Any, Any]

monai.utils.misc.check_kwargs_exist_in_class_init(cls, kwargs)[source]#

检查 kwargs 中的所有键是否存在于类的 __init__ 方法中。

参数:

cls – 要检查的类。
kwargs – 要检查的 kwargs。

返回:

一个布尔值，指示所有键是否存在。一个未在 __init__ 中使用的额外键集合。

monai.utils.misc.check_parent_dir(path, create_dir=True)[source]#

检查 path 的父目录是否存在的功能工具。

参数:

path (Union[str, PathLike]) – 要检查父目录的输入路径。
create_dir (bool) – 如果为 True，则当父目录不存在时创建目录，否则引发异常。

返回类型:

None

monai.utils.misc.copy_to_device(obj, device, non_blocking=True, verbose=False)[source]#

将对象或对象元组/列表/字典复制到 device。

参数:

obj – 要移动到 device 的对象或对象元组/列表/字典。
device – 将 obj 移动到此设备。可以是字符串（例如 cpu、cuda、cuda:0 等）或 torch.device 类型。
non_blocking – 当为 True 时，如果可能，异步将数据移动到设备，例如将具有固定内存的 CPU 张量移动到 CUDA 设备。
verbose – 当为 True 时，将为未复制到 device 的任何不兼容类型的元素打印警告。

返回:

与输入相同，尽可能复制到 device。原始输入将: 保持不变。

monai.utils.misc.ensure_tuple(vals, wrap_array=False)[source]#

返回 vals 的元组。

参数:

vals (Any) – 要转换为元组的输入数据。
wrap_array (bool) – 如果为 True，则将输入的数值数组 (ndarray/tensor) 视为元组的一个项。如果为 False，则尝试使用 tuple(vals) 转换数组，默认为 False。

返回类型:

tuple

monai.utils.misc.ensure_tuple_rep(tup, dim)[source]#

通过缩短或复制输入，返回包含 dim 个值的 tup 副本。

引发:: ValueError – 当 tup 是序列且 tup 长度不是 dim 时。

示例

>>> ensure_tuple_rep(1, 3)
(1, 1, 1)
>>> ensure_tuple_rep(None, 3)
(None, None, None)
>>> ensure_tuple_rep('test', 3)
('test', 'test', 'test')
>>> ensure_tuple_rep([1, 2, 3], 3)
(1, 2, 3)
>>> ensure_tuple_rep(range(3), 3)
(0, 1, 2)
>>> ensure_tuple_rep([1, 2], 3)
ValueError: Sequence must have length 3, got length 2.

返回类型:: tuple[Any, …]

monai.utils.misc.ensure_tuple_size(vals, dim, pad_val=0, pad_from_start=False)[source]#

必要时通过缩短或使用 pad_val 填充，返回包含 dim 个值的 tup 副本。

返回类型:: tuple

monai.utils.misc.fall_back_tuple(user_provided, default, func=<function <lambda>>)[source]#

根据 default 细化 user_provided，并作为经验证的元组返回。

使用 func 对 user_provided 中的每个元素进行验证。如果 func(user_provided[idx]) 返回 False，则将使用相应的 default[idx] 作为备用。

通常用于 user_provided 是用户提供的窗口大小元组，default 由数据定义时。此函数返回一个更新后的 user_provided，其非正数组件被 default 中的相应组件替换。

参数:

user_provided – 要验证的项。
default – 用于提供备用值的序列。
func – 用于验证 user_provided 的每个组件的可调用对象。

示例

>>> fall_back_tuple((1, 2), (32, 32))
(1, 2)
>>> fall_back_tuple(None, (32, 32))
(32, 32)
>>> fall_back_tuple((-1, 10), (32, 32))
(32, 10)
>>> fall_back_tuple((-1, None), (32, 32))
(32, 32)
>>> fall_back_tuple((1, None), (32, 32))
(1, 32)
>>> fall_back_tuple(0, (32, 32))
(32, 32)
>>> fall_back_tuple(range(3), (32, 64, 48))
(32, 1, 2)
>>> fall_back_tuple([0], (32, 32))
ValueError: Sequence must have length 2, got length 1.

monai.utils.misc.first(iterable: Iterable[T], default: T) → T[source]#
monai.utils.misc.first(iterable: Iterable[T]) → T | None: 返回给定可迭代对象中的第一个项，如果为空则返回 default，主要在 'for' 表达式中使用有意义。

monai.utils.misc.has_option(obj, keywords)[source]#: 返回一个布尔值，指示给定可调用对象 obj 的签名中是否包含 keywords。

monai.utils.misc.is_immutable(obj)[source]#

确定对象是否是不可变对象。

另请参阅 python/cpython

返回类型:: bool

monai.utils.misc.is_module_ver_at_least(module, version)[source]#

确定模块的版本是否至少等于给定值。

参数:

module – 已导入模块的名称，例如 np 或 torch。
version – 所需版本，以元组形式给出，例如 (1, 8, 0)。

返回:

如果模块版本等于或晚于给定版本，则为 True。

monai.utils.misc.issequenceiterable(obj)[source]#

确定对象是否为可迭代序列且不是字符串。

返回类型:: bool

monai.utils.misc.label_union(x)[source]#

计算标签中类 ID 的并集，并生成一个包含所有类 ID 的列表 :param x: 一个数字列表（例如，class_IDs）

返回值: 一个列表，显示并集（类 ID 的并集）

monai.utils.misc.list_to_dict(items)[source]#: 将“key=value”对列表转换为字典。例如：items: [“a=1”, “b=2”, “c=3”]，返回: {“a”: “1”, “b”: “2”, “c”: “3”}。如果对中没有“=”，则使用 None 作为值，例如: [“a”]，返回: {“a”: None}。注意，它将移除键和值周围的空格。

monai.utils.misc.path_to_uri(path)[source]#

将文件路径转换为 URI。如果不是绝对路径，将先转换为绝对路径。

参数:: path (Union[str, PathLike]) – 要转换的输入文件路径，可以是字符串或 Path 对象。
返回类型:: str

monai.utils.misc.pprint_edges(val, n_lines=20)[source]#

美观地打印 val 的开头和结尾 n_lines，如果中间部分超过 3 行则省略。

返回: 格式化后的字符串。

返回类型:: str

monai.utils.misc.progress_bar(index, count, desc=None, bar_len=30, newline=False)[source]#

打印进度条以跟踪耗时任务。

参数:

index – 当前进度状态。
count – 进度的总步数。
desc – 进度条的描述，如果不为 None，则在进度条前显示。
bar_len – 屏幕上进度条的总长度，默认为 30 个字符。
newline – 是否在每个索引处换行打印。

monai.utils.misc.run_cmd(cmd_list, **kwargs)[source]#

使用 subprocess.run 运行命令，并设置 capture_output=True 和 stderr=subprocess.STDOUT，以便引发的异常将包含该信息。如果需要，可以显式设置参数 capture_output，但它将被变量中的调试状态覆盖。

参数:

cmd_list (list[str]) – 描述要运行的命令的字符串列表。
kwargs (Any) – subprocess.run 方法支持的关键字参数。

返回类型:

CompletedProcess

返回:

命令完成后，一个 CompletedProcess 实例。

monai.utils.misc.sample_slices(data, dim=1, as_indices=True, *slicevals)[source]#

在指定的 dim 上对输入 numpy 数组或 Tensor 进行切片采样。

参数:

data (Union[ndarray, Tensor]) – 用于切片采样的输入数据，可以是 numpy 数组或 PyTorch Tensor。
dim (int) – 预期进行切片采样的维度索引，默认为 1。
as_indices (bool) – 如果为 True，slicevals 参数将被视为预期的切片索引，例如：1, 3, 5 表示 data[…, [1, 3, 5], …]；如果为 False，slicevals 参数将被视为 slice 函数的参数，例如：1, None 表示 data[…, [1:], …]，1, 5 表示 data[…, [1: 5], …]。
slicevals (int) – 切片索引或预期切片的开始和结束索引，取决于 as_indices 标志。

返回类型:

Union[ndarray, Tensor]

monai.utils.misc.save_obj(obj, path, create_dir=True, atomic=True, func=None, **kwargs)[source]#

将对象保存到指定路径的文件。支持先序列化到临时文件，然后移动到最终目标位置，这样可以保证在发生异常时文件不会损坏。

参数:

obj – 要保存的输入对象数据。
path – 保存输入对象的目标文件路径。
create_dir – 如果路径不存在，是否创建其目录，默认为 True。
atomic – 如果为 True，状态先序列化到临时文件，然后移动到最终目标位置。这样可以保证在发生异常时文件不会损坏。默认为 True。
func – 保存文件的函数，如果为 None，默认为 torch.save。
kwargs – 保存 func 的其他参数，除了检查点和文件名。默认的 func 是 torch.save()，其他参数的详细信息请参阅: https://pytorch.ac.cn/docs/stable/generated/torch.save.html。

monai.utils.misc.set_determinism(seed=4294967295, use_deterministic_algorithms=None, additional_settings=None)[source]#

为模块设置随机种子以启用或禁用确定性训练。

参数:

seed – 要使用的随机种子，默认为 np.iinfo(np.int32).max。建议设置一个大种子，即一个 0 和 1 位分布均衡的数字。避免种子中包含很多 0 位。如果设置为 None，将禁用确定性训练。
use_deterministic_algorithms – 设置 PyTorch 操作是否必须使用“确定性”算法。
additional_settings – 需要设置随机种子的附加设置。

注意

此函数不会影响 monai.transforms.Randomizable 中的随机化对象，它们具有独立的随机状态。对于这些对象，应使用 set_random_state() 方法来确保确定性行为（或者，monai.data.DataLoader 默认根据全局随机状态设置种子，另请参见: monai.data.utils.worker_init_fn 和 monai.data.utils.set_rnd）。

monai.utils.misc.star_zip_with(op, *vals)[source]#: 在 zipWith 中使用 starmap 作为映射函数。

monai.utils.misc.str2bool(value, default=False, raise_exc=True)[source]#

将字符串转换为布尔值。不区分大小写。True: yes, true, t, y, 1。False: no, false, f, n, 0。

参数:

value – 要转换为布尔值的字符串。如果 value 本身已经是布尔值，则直接返回。
raise_exc – 如果 value 不在预期的 true 或 false 输入元组中，是否应引发异常？如果否，则返回 default。

引发

ValueError: value 不在预期的 true 或 false 输入元组中，并且: raise_exc 为 True。

适用于 argparse，例如

parser.add_argument(”–convert”, default=False, type=str2bool) python mycode.py –convert=True

monai.utils.misc.str2list(value, raise_exc=True)[source]#

将字符串转换为列表。适用于 argparse 命令行参数: parser.add_argument(”–blocks”, default=[1,2,3], type=str2list) python mycode.py –blocks=1,2,2,4

参数:

value – 要转换为列表的字符串（逗号分隔）
raise_exc – 如果无法转换为列表，则引发异常

引发: ValueError: value 不是字符串或列表，或无法转换

monai.utils.misc.to_tuple_of_dictionaries(dictionary_of_tuples, keys)[source]#

给定一个字典，其值包含标量或元组（与 keys 长度相同），为每个键创建一个包含映射到该键的标量值的字典。

参数:

dictionary_of_tuples (dict) – 一个字典，其值是标量或长度与 keys 长度相同的元组
keys (Any) – 一个字符串值元组，表示相关的键

返回类型:

tuple[dict[Any, Any], …]

返回:

一个包含标量值的字典元组，每个键对应一个字典

引发:

ValueError – 当字典中的值是元组但长度与
keys 的长度不相同时 –

示例

>>> to_tuple_of_dictionaries({'a': 1 'b': (2, 3), 'c': (4, 4)}, ("x", "y"))
({'a':1, 'b':2, 'c':4}, {'a':1, 'b':3, 'c':4})

monai.utils.misc.zip_with(op, *vals, mapfunc=<class 'map'>)[source]#: 使用 mapfunc 将 op 映射到由 vals 中的可迭代对象压缩而成的每个元组。

NVTX 注释#

用于 NVIDIA 工具扩展的装饰器和上下文管理器，以分析 MONAI 组件。

class monai.utils.nvtx.Range(name=None, methods=None, append_method_name=None, recursive=False)[source]#

NVIDIA 工具扩展 (NVTX) Range 的装饰器和上下文管理器，用于性能分析。用作装饰器时，它使用 NVTX Range 封装对象的特定方法。用作上下文管理器时，它使用 NVTX Range 封装运行时上下文（由 with 语句创建）。

参数:

name – 与该 Range 关联的名称
methods – （仅在用作装饰器时）要由 NVTX Range 封装的方法的名称（或方法名称列表）。如果为 None（默认），将根据对象类型推断各种 MONAI 组件（例如 Networks、Losses、Functions、Transforms 和 Datasets）的方法。否则，它将查找预定义的方法：“forward”、“__call__”、“__next__”、“__getitem__”。
append_method_name – 是否将要装饰的方法的名称附加到 Range 的名称后。如果为 None（默认），则仅在注释多个方法时附加方法名称。
recursive – 如果设置为 True，将递归地注释列表或模块链（使用 Compose 链接）中的每个独立模块。默认为 False。

性能分析#

class monai.utils.profiling.PerfContext[source]#: 用于跟踪在上下文块中花费了多少时间的上下文管理器。它使用 time.perf_counter 累积对象在使用的任意数量的上下文块中的总时间（以秒为单位），并将其存储在属性 total_time 中。

class monai.utils.profiling.ProfileHandler(name, profiler, start_event, end_event)[source]#

用于 Ignite Engine 类的处理程序，测量从开始事件到结束事件的时间。这可用于对 ignite.engine.Events 中定义的 epoch、迭代和其他事件进行性能分析。此类只能在性能分析器对象的上下文中使用。

参数:

name – 要分析的事件名称
profiler – 处理程序使用的 WorkflowProfiler 实例，应在此对象的上下文中使用
start_event – ignite.engine.Events 中的项，指示开始计时的事件
end_event – ignite.engine.Events 中的项，指示停止计时的事件

class monai.utils.profiling.WorkflowProfiler(call_selector=<function select_transform_call>)[source]#

用于测量工作流程所有方面时间的性能分析器。这包括使用堆栈跟踪捕获所有选定调用（默认为 Transform.__call__ 方法的调用）的调用时间、上下文块内的时间、从可迭代对象生成项的时间以及执行装饰函数的时间。

此性能分析器必须在其上下文中使用，因为它使用内部线程从多进程队列读取结果。这使得性能分析器可以在多个线程和进程中工作，尽管多进程跟踪有时不可靠，并且在 Windows 中完全不可用。

Profiler 使用 sys.settrace 和 threading.settrace 来查找所有需要进行性能分析的调用，这将在上下文进入时设置，并在退出时清除，因此正确使用上下文对于防止过度跟踪至关重要。请注意，跟踪开销很高，因此时间不能准确反映真实世界性能，但可以大致了解时间消耗的相对份额。

跟踪功能使用一个选择器来选择要跟踪的调用，因为跟踪所有调用会导致无限循环，即使不这样也会非常慢。这个选择器是一个可调用对象，接受一个 call 跟踪帧，并返回 True 表示应该跟踪该调用。默认值是 select_transform_call，它仅对 Transform.__call__ 调用返回 True。

展示所有性能分析函数用法的示例

import monai.transform as mt
from monai.utils import WorkflowProfiler
import torch

comp=mt.Compose([mt.ScaleIntensity(),mt.RandAxisFlip(0.5)])

with WorkflowProfiler() as wp:
    for _ in wp.profile_iter("range",range(5)):
        with wp.profile_ctx("Loop"):
            for i in range(10):
                comp(torch.rand(1,16,16))

    @wp.profile_callable()
    def foo(): pass

    foo()
    foo()

print(wp.get_times_summary_pd())  # print results

参数:: call_selector – 用于确定要跟踪哪些调用的选择器，使用 None 可禁用跟踪

add_result(result)[source]#

以线程安全的方式向内部结果字典添加结果。

返回类型:: None

dump_csv(stream=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#: 将所有结果保存到 csv 文件。

get_results()[source]#: 获取一个新的结果字典，其中包含新的 ProfileResult 对象元组。

get_times_summary(times_in_s=True)[source]#: 返回一个字典，将结果条目映射到包含项目数量、时间总和、时间平均值、时间标准差、时间最小值和时间最大值的元组。

get_times_summary_pd(times_in_s=True)[source]#: 返回与 get_times_summary 相同的信息，但采用 Pandas DataFrame 格式。

profile_callable(name=None)[source]#: 可应用于函数的装饰器，用于对其进行的任何调用进行性能分析。所有对被装饰可调用对象的调用都必须在 profiler 的上下文内完成。

profile_ctx(name, caller=None)#: 创建一个用于性能分析的上下文，并在退出时将计时结果放入队列。

profile_iter(name, iterable)[source]#: 任何可迭代对象周围的包装器，用于分析生成项目所需的时间。

monai.utils.profiling.select_transform_call(frame)[source]#: 如果 frame 是对 Transform 对象的 _call__ 方法的调用，则返回 True。

monai.utils.profiling.torch_profiler_full(func)[source]#: 一个装饰器，将对被装饰的函数运行 torch profiler，并完整打印结果。注意：强制执行 gpu 同步点，这可能会减慢流水线速度。

monai.utils.profiling.torch_profiler_time_cpu_gpu(func)[source]#: 一个装饰器，用于测量被装饰函数的 CPU 和 GPU 组件的执行时间，并打印两个结果。注意：强制执行 gpu 同步点，这可能会减慢流水线速度。

monai.utils.profiling.torch_profiler_time_end_to_end(func)[source]#: 一个装饰器，用于测量从调用被装饰函数到最后一个 cuda 操作完成的整个执行时间，并打印结果。注意：强制执行 gpu 同步点，这可能会减慢流水线速度。

已弃用#

exception monai.utils.deprecate_utils.DeprecatedError[source]#

monai.utils.deprecate_utils.deprecated(since=None, removed=None, msg_suffix='', version_val='1.4.0', warning_category=<class 'FutureWarning'>)[source]#

monai.utils.deprecate_utils.deprecated(since=None, removed=None, msg_suffix='', version_val='1.4.0', warning_category=<class 'FutureWarning'>)[source]#

标记一个函数或类为已弃用。如果给定 since，这应该是一个早于或等于当前版本的版本，并说明在该版本中定义被标记为已弃用。如果给定 removed，这可以是任何版本，并标记定义被移除的时间。

当调用被装饰的定义时，即当函数被调用或类被实例化时，如果给定了 since 且当前版本等于或晚于给定版本，则会发出 warning_category 警告。如果给定了 removed 且当前版本等于或晚于该版本，或者既未提供 since 也未提供 removed，则会引发 DeprecatedError 异常。

参数:

相应地，被弃用函数的相关文档字符串也应更新，使用 Sphinx 指令，例如 .. versionchanged:: version 和 .. deprecated:: version。https://sphinx-doc.cn/en/master/usage/restructuredtext/directives.html#directive-versionadded
since – 定义被标记为已弃用但未移除的版本。
removed – 定义已被/将被移除且不再可用的版本。
msg_suffix – 附加到警告/异常消息的后缀，详细说明弃用原因和应使用什么替代。
version_val – （用于测试）与 since 和 removed 进行比较的版本，默认为 MONAI 版本。

返回:

warning_category – 警告类别类，默认为 FutureWarning。

被装饰的定义，使用时会发出警告或引发异常

monai.utils.deprecate_utils.deprecated_arg(name, since=None, removed=None, msg_suffix='', version_val='1.4.0', new_name=None, warning_category=<class 'FutureWarning'>)[source]#

标记一个可调用对象的特定命名参数为已弃用。条件与 deprecated 装饰器中描述的 since 和 removed 相同。

参数:

当调用被装饰的定义时，即当使用参数调用函数或实例化类时，如果给定了 since 且当前版本等于或晚于给定版本，则会发出 warning_category 警告。如果给定了 removed 且当前版本等于或晚于该版本，或者既未提供 since 也未提供 removed，则会引发 DeprecatedError 异常。
name – 要标记为已弃用的位置参数或关键字参数的名称。
since – 参数被标记为已弃用但未移除的版本。
removed – 定义已被/将被移除且不再可用的版本。
msg_suffix – 附加到警告/异常消息的后缀，详细说明弃用原因和应使用什么替代。
removed – 参数已被/将被移除且不再可用的版本。
version_val – （用于测试）与 since 和 removed 进行比较的版本，默认为 MONAI 版本。

返回:

new_name – 替换已弃用参数的位置参数或关键字参数的名称。如果指定了此参数且被装饰函数的签名具有 kwargs，则传递给已弃用参数 name 的值将被移除。

使用已弃用参数时会发出警告或引发异常的被装饰可调用对象。

monai.utils.deprecate_utils.deprecated_arg_default(name, old_default, new_default, since=None, replaced=None, msg_suffix='', version_val='1.4.0', warning_category=<class 'FutureWarning'>)[source]#

标记一个可调用对象的特定参数的默认值已弃用。其默认值在版本 changed 中从 old_default 更改为 new_default。

参数:

当调用被装饰的定义时，如果给定了 since，并且调用者没有显式设置默认值，并且当前版本等于或晚于给定版本，则会发出 warning_category 警告。如果给定了 changed 且当前版本等于或晚于该版本，则会发出另一个具有相同类别的警告。
name – 默认值已弃用/更改的位置参数或关键字参数的名称。
old_default – 旧默认值的名称。这仅用于警告消息，不会进行验证。
new_default – 新默认值的名称。在版本 replaced 之前，验证此值是否不存在作为默认值。这意味着，如果实际的默认值是 None 并在函数稍后设置，您也可以使用此选项。您也可以将其设置为任何字符串表示形式，例如 “calculate_default_value()”，如果默认值是从另一个函数计算得出的。
since – 参数默认值被标记为已弃用但未替换的版本。
replaced – 参数默认值已被/将被替换的版本。
msg_suffix – 附加到警告/异常消息的后缀，详细说明弃用原因和应使用什么替代。
version_val – （用于测试）与 since 和 removed 进行比较的版本，默认为 MONAI 版本。

返回:

msg_suffix – 附加到警告/异常消息的后缀，详细说明弃用原因。

被装饰的可调用对象，当未显式指定已弃用的默认参数时会发出警告。

类型转换#

monai.utils.type_conversion.convert_data_type(data, output_type=None, device=None, dtype=None, wrap_sequence=False, safe=False)[source]#

参数:

从 MetaTensor、torch.Tensor、np.ndarray、float、int 等转换为 MetaTensor、torch.Tensor 或 np.ndarray。
data – 要转换的数据
output_type – monai.data.MetaTensor、torch.Tensor 或 np.ndarray（如果为 None，则不变）
device – 如果输出是 MetaTensor 或 torch.Tensor，则选择设备（如果为 None，则不变）
dtype – 输出数据的数据类型。转换为正确的库类型（例如，如果输出类型是 torch.Tensor，则 np.float32 转换为 torch.float32）。如果留空，则保持不变。
wrap_sequence – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [array(1), array(2)]。如果为 True，则 [1, 2] -> array([1, 2])。

返回:

safe – 如果为 True，则在强度溢出时进行安全的数据类型转换。默认为 False。例如，[256, -12] -> [array(0), array(244)]。如果为 True，则 [256, -12] -> [array(255), array(0)]。

注意

修改后的数据、原始类型、原始设备

>>> convert_data_type(1, torch.Tensor, dtype=np.float32)
(1.0, <class 'torch.Tensor'>, None)

当 output_type 和 dtype 都指定了不同的后端（例如，torch.Tensor 和 np.float32）时，output_type 将用作主要类型，例如

monai.utils.type_conversion.convert_to_cupy(data, dtype=None, wrap_sequence=False, safe=False)[source]#

参数:

将输入数据转换为 cupy 数组的实用工具。如果传入字典、列表或元组，则递归检查每个项目并将其转换为 cupy 数组。
data – 输入数据可以是 PyTorch Tensor、numpy 数组、cupy 数组、列表、字典、int、float、bool、str 等。Tensor、numpy 数组、cupy 数组、float、int、bool 将转换为 cupy 数组，字符串和对象保持原样。对于字典、列表或元组，如果适用，将每个项目转换为 numpy 数组。
dtype – 输出数据的数据类型。转换为正确的库类型（例如，如果输出类型是 torch.Tensor，则 np.float32 转换为 torch.float32）。如果留空，则保持不变。
wrap_sequence – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [array(1), array(2)]。如果为 True，则 [1, 2] -> array([1, 2])。

dtype – 转换为 Cupy 数组时的目标数据类型，必须是 numpy.dtype 的参数，更多详细信息请参见：https://docs.cupy.dev/en/stable/reference/generated/cupy.array.html。

monai.utils.type_conversion.convert_to_dst_type(src, dst, dtype=None, wrap_sequence=False, device=None, safe=False)[source]#

参数:

将源数据转换为与目标数据相同的数据类型和设备。如果 dst 是 torch.Tensor 或其子类的实例，则将 src 转换为与 dst 具有相同数据类型的 torch.Tensor；如果 dst 是 numpy.ndarray 或其子类的实例，则转换为与 dst 具有相同数据类型的 numpy.ndarray；否则，直接转换为 dst 的类型。
src – 要转换类型的源数据。
dst – 作为目标数据，转换为与其相同的数据类型。
dtype – 输出数据的数据类型。转换为正确的库类型（例如，如果输出类型是 torch.Tensor，则 np.float32 转换为 torch.float32）。如果留空，则保持不变。
dtype – 可选参数，如果目标 dtype 与原始 dst 的数据类型不同。
wrap_sequence – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [array(1), array(2)]。如果为 True，则 [1, 2] -> array([1, 2])。

device – 存放转换后的 Tensor 数据的目标设备。如果未指定，则尽可能使用 dst.device。

另请参阅

convert_data_type()

monai.utils.type_conversion.convert_to_numpy(data, dtype=None, wrap_sequence=False, safe=False)[source]#

参数:

将输入数据转换为 numpy 数组的实用工具。如果传入字典、列表或元组，则递归检查每个项目并将其转换为 numpy 数组。
data (Any) – 输入数据可以是 PyTorch Tensor、numpy 数组、列表、字典、int、float、bool、str 等。会将 Tensor、Numpy 数组、float、int、bool 转换为 numpy 数组，字符串和对象保持原样。对于字典、列表或元组，如果适用，将每个项目转换为 numpy 数组。
dtype (Union[dtype, type, str, None]) – 转换为 numpy 数组时的目标数据类型。
wrap_sequence (bool) – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [array(1), array(2)]。如果为 True，则 [1, 2] -> array([1, 2])。

返回类型:

Any

safe (bool) – 如果为 True，则在强度溢出时进行安全的数据类型转换。默认为 False。例如，[256, -12] -> [array(0), array(244)]。如果为 True，则 [256, -12] -> [array(255), array(0)]。

monai.utils.type_conversion.convert_to_tensor(data, dtype=None, device=None, wrap_sequence=False, track_meta=False, safe=False)[source]#

参数:

将输入数据转换为 PyTorch Tensor 的实用工具，如果 track_meta 为 True，则输出将是 MetaTensor，否则，输出将是常规的 torch Tensor。如果传入字典、列表或元组，则递归检查每个项目并将其转换为 PyTorch Tensor。
data – 输入数据可以是 PyTorch Tensor、numpy 数组、列表、字典、int、float、bool、str 等。会将 Tensor、Numpy 数组、float、int、bool 转换为 Tensor，字符串和对象保持原样。对于字典、列表或元组，如果适用，将每个项目转换为 Tensor。
dtype – 转换为 Tensor 时的目标数据类型。
device – 存放转换后的 Tensor 数据的目标设备。
wrap_sequence – 如果为 False，则列表将递归调用此函数。例如，[1, 2] -> [tensor(1), tensor(2)]。如果为 True，则 [1, 2] -> tensor([1, 2])。
track_meta – 是否跟踪元信息，如果为 True，将转换为 MetaTensor。默认为 False。

safe – 如果为 True，则在强度溢出时进行安全的数据类型转换。默认为 False。例如，[256, -12] -> [tensor(0), tensor(244)]。如果为 True，则 [256, -12] -> [tensor(255), tensor(0)]。

monai.utils.type_conversion.dtype_numpy_to_torch(dtype)[source]#

返回类型:: 将 numpy 数据类型转换为其等效的 torch 数据类型。

数据类型

monai.utils.type_conversion.dtype_torch_to_numpy(dtype)[source]#

返回类型:: 将 numpy 数据类型转换为其等效的 torch 数据类型。

将 torch 数据类型转换为其等效的 numpy 数据类型。

monai.utils.type_conversion.get_dtype(data)[source]#

获取图像的数据类型，如果是一个序列，则递归调用第 0 个元素的方法。

因此，这假设在 Sequence 中，所有类型都相同。: monai.utils.type_conversion.get_dtype_string(dtype)[source]#

获取数据类型的字符串表示形式。

monai.utils.type_conversion.get_equivalent_dtype(dtype, data_type)[source]#

转换为与 data_type 对应的数据类型 dtype。

输入数据类型也可以是字符串。例如，“float32” 根据需要变为 torch.float32 或 np.float32。

im = torch.tensor(1)
dtype = get_equivalent_dtype(np.float32, type(im))

示例

monai.utils.type_conversion.get_numpy_dtype_from_string(dtype)[source]#

返回类型:: 将 numpy 数据类型转换为其等效的 torch 数据类型。

从其字符串形式（例如，“float32”）获取 numpy 数据类型（例如，np.float32）。

monai.utils.type_conversion.get_torch_dtype_from_string(dtype)[source]#

返回类型:: 将 numpy 数据类型转换为其等效的 torch 数据类型。

从其字符串形式（例如，“float32”）获取 torch 数据类型（例如，torch.float32）。

装饰器#

class monai.utils.decorators.MethodReplacer(meth)[source]#

方法装饰器的基类，可用于将传递给 replace_method() 的方法替换为包装后的版本。: replace_method(meth)[source]#

返回一个新方法来替换实例化对象中的 meth，或返回 meth 以不做任何操作。: class monai.utils.decorators.RestartGenerator(create_gen)[source]#

包装一个生成器可调用对象，每当对此类进行迭代时，都会调用该对象并返回其结果。这用于创建一个可以多次迭代给定生成器的迭代器。

分布式数据并行#

class monai.utils.dist.RankFilter(rank=None, filter_fn=<function RankFilter.<lambda>>)[source]#

参数:

RankFilter 类是一个方便的过滤器，它扩展了 Python 日志模块中的 Filter 类。目的是控制基于分布式环境中 rank 处理哪些日志记录。
rank – 进程在 torch.distributed 中的 rank。默认为 None，然后将使用 dist.get_rank()。

filter_fn – 用作过滤条件的 optional lambda 函数。默认函数仅在进程 rank 为 0 时记录，但用户可以定义自己的函数来实现自定义过滤逻辑。

filter(*_args)[source]#

确定是否应该记录指定的记录。

如果应该记录记录，则返回 True，否则返回 False。如果认为适当，记录可以原地修改。

monai.utils.dist.evenly_divisible_all_gather(data: Tensor, concat: Literal[True]) → Tensor[source]#

monai.utils.dist.evenly_divisible_all_gather(data: Tensor, concat: Literal[False]) → list[Tensor]

monai.utils.dist.evenly_divisible_all_gather(data: Tensor, concat: bool) → torch.Tensor | list[torch.Tensor]

分布式数据并行实用函数，用于在第一个维度进行填充以使其可被均匀整除，然后进行 all_gather。每个 rank 的输入数据应该具有相同的维数，只有第一个维度可以不同。

参数:

注意：如果安装了 ignite，将基于 ignite 分布式 API 执行，否则，如果初始化了原生 PyTorch 分布式组，将基于原生 PyTorch 分布式 API 执行。
data – 要在分布式数据并行中进行填充和执行 all_gather 的源 tensor。

注意

concat – 是否将收集到的列表连接成一个 Tensor，如果为 False，则返回 Tensor 列表，行为类似于 torch.distributed.all_gather()。默认为 True。

不同 rank 上的输入数据必须具有完全相同的 dtype。: monai.utils.dist.get_dist_device()[source]#

在原生 PyTorch 分布式数据并行中获取预期的目标设备。对于 NCCL 后端，返回当前进程的 GPU 设备。对于 GLOO 后端，返回 CPU。对于任何其他后端，默认为 None，tensor.to(None) 不会改变设备。

monai.utils.dist.string_list_all_gather(strings, delimiter='\\t')[source]#

参数:

分布式数据并行实用函数，用于 all gather 字符串列表。参考 ignite all_gather(string) 的思想：https://pytorch.ac.cn/ignite/v0.4.5/distributed.html#ignite.distributed.utils.all_gather。
strings (list[str]) – 要 all gather 的字符串列表。

返回类型:

delimiter (str) – 使用分隔符将字符串列表连接成一个长字符串，然后在 rank 之间进行 all gather 并分割成列表。默认为 “\t”。

`list`[`str`]

枚举#: class monai.utils.enums.AlgoKeys(value)[source]#

模板化 Auto3DSeg Algo 的默认键。ID 是算法的标识符。字符串格式为 <name>_<idx>_<other>。ALGO 是 Auto3DSeg Algo 实例。IS_TRAINED 表示 Algo 是否已训练的状态。SCORE 是 Algo 训练后获得的得分。: class monai.utils.enums.Average(value)[source]#

另请参阅：monai.metrics.rocauc.compute_roc_auc: class monai.utils.enums.BlendMode(value)[source]#

另请参阅：monai.data.utils.compute_importance_map: class monai.utils.enums.BoxModeName(value)[source]#

边界框模式名称。: class monai.utils.enums.BundleProperty(value)[source]#

Bundle 属性字段：DESC 是属性的描述。REQUIRED 是指示属性是否为必需或可选的标志。: class monai.utils.enums.BundlePropertyConfig(value)[source]#

基于配置的 bundle 工作流的附加 bundle 属性字段：ID 是属性的配置项 ID。REF_ID 是应该引用此属性的配置项的 ID。对于没有 REF_ID 的属性，应设置为 None。此字段仅用于检查 optional 属性 ID。: class monai.utils.enums.ChannelMatching(value)[source]#

另请参阅：monai.networks.nets.HighResBlock: class monai.utils.enums.ColorOrder(value)[source]#

颜色顺序的枚举。根据需要扩展。: class monai.utils.enums.CommonKeys(value)[source]#

基于字典的监督训练过程的常用键集。IMAGE 是输入图像数据。LABEL 是分割或分类任务的训练或评估标签。PRED 是模型输出的预测数据。LOSS 是当前迭代的损失值。INFO 是训练或评估过程中的一些有用信息，例如损失值等。

class monai.utils.enums.CompInitMode(value)[source]#

实例化类或调用可调用对象的模式名称。

另请参阅：monai.utils.module.instantiate(): class monai.utils.enums.DataStatsKeys(value)[source]#

数据集统计分析模块的默认键

device – 存放转换后的 Tensor 数据的目标设备。如果未指定，则尽可能使用 dst.device。

class monai.utils.enums.DiceCEReduction(value)[source]#

monai.losses.dice.DiceCELoss: class monai.utils.enums.EngineStatsKeys(value)[source]#

trainer 和 evaluator 引擎统计信息的默认键。: class monai.utils.enums.FastMRIKeys(value)[source]#

用于从 fastMRI 数据集中提取数据的键: class monai.utils.enums.ForwardMode(value)[source]#

另请参阅：monai.transforms.engines.evaluator.Evaluator: class monai.utils.enums.GanKeys(value)[source]#

生成对抗网络的常用键集。: class monai.utils.enums.GridPatchSort(value)[source]#

GridPatch 中生成补丁的排序方法

class monai.utils.enums.GridSampleMode(value)[source]#

另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html

注意

torch.nn.functional.grid_sample 的插值模式

（文档来自 torch.nn.functional.grid_sample）mode=’bicubic’ 仅支持 4-D 输入。当 mode=’bilinear’ 且输入为 5-D 时，内部使用的插值模式实际上是三线性。但是，当输入为 4-D 时，插值模式将是真正的双线性。: class monai.utils.enums.GridSampleMode(value)[source]#

class monai.utils.enums.GridSamplePadMode(value)[source]#: class monai.utils.enums.HoVerNetBranch(value)[source]#

HoVerNet 模型的三个分支，产生三个输出：HV 是每个细胞核的水平和垂直梯度图（回归），NP 是所有细胞核的像素预测（分割），NC 是每个细胞核的类型（分类）。: class monai.utils.enums.HoVerNetMode(value)[source]#

HoVerNet 模型的模式：FAST：更快的实现（比原始版本）ORIGINAL：原始实现: class monai.utils.enums.IgniteInfo(value)[source]#

PyTorch ignite 包的配置信息。: class monai.utils.enums.ImageStatsKeys(value)[source]#

数据集统计分析图像模块的默认键: class monai.utils.enums.InterpolateMode(value)[source]#

另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html: class monai.utils.enums.LabelStatsKeys(value)[source]#

数据集统计分析标签模块的默认键: class monai.utils.enums.LazyAttr(value)[source]#

MetaTensor 带有待处理的操作，需要跟踪一些关键属性，尤其是当主数组由于延迟评估而未更新时。此类指定了每个 MetaTensor 要跟踪的关键属性集。另请参阅 monai.transforms.lazy.utils.resample() 了解更多详细信息。

device – 存放转换后的 Tensor 数据的目标设备。如果未指定，则尽可能使用 dst.device。

monai.losses.tversky.TverskyLoss: class monai.utils.enums.MetaKeys(value)[source]#

MetaObj.meta 的常用键: class monai.utils.enums.Method(value)[source]#

另请参阅：monai.transforms.croppad.array.SpatialPad: class monai.utils.enums.MetricReduction(value)[source]#

另请参阅：monai.metrics.utils.do_metric_reduction(): class monai.utils.enums.NdimageMode(value)[source]#

可用选项决定了插值时输入数组在其边界之外如何扩展。另请参阅：https://docs.scipy.org.cn/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html: class monai.utils.enums.NumpyPadMode(value)[source]#

另请参阅：https://numpy.com.cn/doc/1.18/reference/generated/numpy.pad.html: class monai.utils.enums.PostFix(value)[source]#

后缀。: class monai.utils.enums.PytorchPadMode(value)[source]#

另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.pad.html: class monai.utils.enums.SkipMode(value)[source]#

class monai.utils.enums.SpaceKeys(value)[source]#: 坐标系键，例如，Nifti1 使用 Right-Anterior-Superior（“RAS”），DICOM (0020,0032) 使用 Left-Posterior-Superior（“LPS”）。这种类型不区分空间 1/2/3D。

class monai.utils.enums.SplineMode(value)[source]#

样条插值的阶数。

另请参阅：https://docs.scipy.org.cn/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html

class monai.utils.enums.StrEnum(value)[source]#

将其值转换为字符串的 Enum 子类。

from monai.utils import StrEnum

class Example(StrEnum):
    MODE_A = "A"
    MODE_B = "B"

assert (list(Example) == ["A", "B"])
assert Example.MODE_A == "A"
assert str(Example.MODE_A) == "A"
assert monai.utils.look_up_option("A", Example) == "A"

class monai.utils.enums.TraceKeys(value)[source]#: 用于可追溯变换的额外元数据键。

class monai.utils.enums.TraceStatusKeys(value)[source]#: TraceKeys.STATUS 标志的可枚举状态键

class monai.utils.enums.TransformBackends(value)[source]#: 变换后端。大多数 monai.transforms 组件首先将输入数据转换为 torch.Tensor 或 monai.data.MetaTensor。在内部，一些变换通过将数据转换为 numpy.array 或 cupy.array 并使用底层变换后端 API 来实现实际输出数组，然后转换回 Tensor/MetaTensor 来完成。具有多个后端的变换表示它们可能会转换输入数据类型以适应底层 API。

class monai.utils.enums.UpsampleMode(value)[source]#: 另请参阅：monai.networks.blocks.UpSample

class monai.utils.enums.Weight(value)[source]#: 另请参阅：monai.losses.dice.GeneralizedDiceLoss

Jupyter 工具函数#

这组实用函数旨在使在 Jupyter notebook 中使用 MONAI 更加容易。使用 Matplotlib 的绘图函数可以生成常见的指标和图像图。

class monai.utils.jupyter_utils.StatusMembers(value)[source]#: 状态字典中的命名成员，其他成员可能用于命名指标值。

class monai.utils.jupyter_utils.ThreadContainer(engine, loss_transform=<function _get_loss_from_output>, metric_transform=<function ThreadContainer.<lambda>>, status_format='{}: {:.4}')[source]#

在 Jupyter notebook 中，在主线程的独立线程中包含一个正在运行的 Engine 对象。这使得引擎可以在后台开始运行，并允许启动 notebook 单元格完成。因此，用户可以启动运行，然后导航离开 notebook，而不必担心与正在运行的单元格失去连接。所有输出都通过与正在运行的引擎使用内部 lock 成员同步的方法获取；获取此锁允许在引擎被阻止开始下一次迭代时对其进行检查。

参数:

engine (Engine) – 被包装的 Engine 对象，容器启动时会调用其 run 方法
loss_transform (Callable) – 将输出字典转换为单个数值的可调用对象
metric_transform (Callable) – 将命名指标值转换为单个数值的可调用对象
status_format (str) – 状态键值对的格式字符串。

plot_status(logger, plot_func=<function plot_engine_status>)[source]#: 生成包含引擎当前状态的图，其损失和指标由 logger 跟踪。函数 plot_func 必须接受参数 title、engine、logger 和 fig，它们分别是图标题、self.engine、logger 和 self.fig。返回值必须是一个图对象（存储在 self.fig 中）以及图中所有图的 Axes 对象列表。此方法只返回图对象，并在生成图期间持有内部锁。

run()[source]#: 调用被包装引擎的 run 方法。

status()[source]#

返回引擎当前状态的状态字符串。

返回类型:: str

property status_dict: dict[str, str]#

一个包含状态信息、当前损失和当前指标值的字典。

返回类型:: dict[str, str]

stop()[source]#: 停止引擎并等待线程结束。

monai.utils.jupyter_utils.plot_engine_status(engine, logger, title='Training Log', yscale='log', avg_keys=('loss', ), window_fraction=20, image_fn=<function tensor_to_images>, fig=None, selected_inst=0)[source]#

绘制给定 Engine 及其记录器的状态图。图将由损失值和从记录器获取的指标图，以及从 engine.state 的 output 和 batch 成员获取的图像组成。图像使用 image_fn 转换为适用于 Axes.imshow 输入的 Numpy 数组，如果此参数为 None，则不绘制图像。

参数:

engine – 用于提取图像的 Engine
logger – 用于提取损失和指标数据的 MetricLogger
title – 图标题
yscale – 用于指标图，与 Axes.set_yscale 兼容的 y 轴刻度
avg_keys – 用于指标图，graphmap 中需要提供运行平均图的键元组
window_fraction – 用于指标图，用作运行平均窗口的图值长度的比例
image_fn – 将 Engine 中按名称键控的张量转换为要绘制的图像元组的可调用对象
fig – 用于绘制的 Figure 对象，从之前的绘图中复用以实现无闪烁刷新
selected_inst – 在图像图中显示的实例索引

返回:

Figure 对象（如果给出则为 fig），用于图和图像的 Axes 对象列表

monai.utils.jupyter_utils.plot_metric_graph(ax, title, graphmap, yscale='log', avg_keys=('loss',), window_fraction=20)[source]#

在单个图上绘制指标，并为选定的键绘制运行平均线。 graphmap 中的值应为 (时间点, 值) 对的列表，如 MetricLogger 对象中存储的。

参数:

ax – 用于绘制的 Axes 对象
title – 图标题
graphmap – 命名图值的字典，其值是值的列表或 (索引, 值) 对
yscale – 与 Axes.set_yscale 兼容的 y 轴刻度
avg_keys – graphmap 中需要提供运行平均图的键元组
window_fraction – 用作运行平均窗口的图值长度的比例

monai.utils.jupyter_utils.plot_metric_images(fig, title, graphmap, imagemap, yscale='log', avg_keys=('loss',), window_fraction=20)[source]#

将指标图数据和图像绘制到图 fig 中。预期用途是将图数据作为训练运行的指标，并将图像作为最后一次迭代的批次和输出。这使用 plot_metric_graph 来绘制指标图。

参数:

fig – 用于绘制的 Figure 对象，从之前的绘图中复用以实现无闪烁刷新
title – 图标题
graphmap – 命名图值的字典，其值是值的列表或 (索引, 值) 对
imagemap – 需要与指标图一起显示的命名图像字典
yscale – 用于指标图，与 Axes.set_yscale 兼容的 y 轴刻度
avg_keys – 用于指标图，graphmap 中需要提供运行平均图的键元组
window_fraction – 用于指标图，用作运行平均窗口的图值长度的比例

返回:

Axes 对象列表，先是图，然后是图像

monai.utils.jupyter_utils.tensor_to_images(name, tensor)[source]#: 返回从给定张量导出的图像元组。 name 值索引张量存储在输出或批次值中的键，如果它们是单个张量而不是字典，则为“Batch”或“Output”。返回形状为 HW 的 2D 图像元组，或形状为 CHW 的 3D 图像元组，其中 C 是颜色通道 RGB 或 RGBA。这允许从单个张量创建多个图像，例如，单独显示每个通道。

状态缓存器#

class monai.utils.state_cacher.StateCacher(in_memory, cache_dir=None, allow_overwrite=True, pickle_module=<module 'pickle' from '/home/docs/.asdf/installs/python/3.9.19/lib/python3.9/pickle.py'>, pickle_protocol=2)[source]#

用于缓存和检索对象状态的类。

对象可以存储在内存中或磁盘上。如果存储在磁盘上，它们可以存储在给定目录中，或者使用临时位置。任何创建的文件将在 StateCacher 的析构函数中删除。

如果必要/可能，恢复的对象将被返回到其原始设备。

输入数据类型也可以是字符串。例如，“float32” 根据需要变为 torch.float32 或 np.float32。

>>> state_cacher = StateCacher(memory_cache, cache_dir=cache_dir)
>>> state_cacher.store("model", model.state_dict())
>>> model.load_state_dict(state_cacher.retrieve("model"))

__init__(in_memory, cache_dir=None, allow_overwrite=True, pickle_module=<module 'pickle' from '/home/docs/.asdf/installs/python/3.9.19/lib/python3.9/pickle.py'>, pickle_protocol=2)[source]#

构造函数。

参数:

in_memory – 布尔值，用于确定对象是缓存在内存中还是磁盘上。
cache_dir – 如果 in_memory==False，用于缓存数据的目录。默认为使用临时目录。创建的任何文件将在 StateCacher 的析构函数期间被删除。
allow_overwrite – 允许覆盖缓存。如果设置为 False，如果缓存对象列表中已存在匹配项，则会引发错误。
pickle_module – 用于序列化元数据和对象的模块，默认为 pickle。此参数由 torch.save 使用，更多详细信息，请查看：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。
pickle_protocol – 可以指定以覆盖默认协议，默认为 2。此参数由 torch.save 使用，更多详细信息，请查看：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。

retrieve(key)[source]#

检索存储在给定键名下的对象。

返回类型:: Any

store(key, data_obj, pickle_module=None, pickle_protocol=None)[source]#

使用给定的键名存储给定对象。

参数:

key – 要存储的数据对象的键。
data_obj – 要存储的数据对象。
pickle_module – 用于序列化元数据和对象的模块，默认为 self.pickle_module。此参数由 torch.save 使用，更多详细信息，请查看：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。
pickle_protocol – 可以指定以覆盖默认协议，默认为 self.pickle_protocol。此参数由 torch.save 使用，更多详细信息，请查看：https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。

组件存储#

class monai.utils.component_store.ComponentStore(name, description)[source]#

表示一个存储其他对象（特别是函数）的对象，通过名称和描述进行键控。

这些对象充当全局命名位置，用于存储由组件名称参数化的对象的组件。通常这是函数，尽管也可以添加其他对象。打印组件存储将生成成员列表及其（如果存在）文档字符串信息。

输入数据类型也可以是字符串。例如，“float32” 根据需要变为 torch.float32 或 np.float32。

TestStore = ComponentStore("Test Store", "A test store for demo purposes")

@TestStore.add_def("my_func_name", "Some description of your function")
def _my_func(a, b):
    '''A description of your function here.'''
    return a * b

print(TestStore)  # will print out name, description, and 'my_func_name' with the docstring

func = TestStore["my_func_name"]
result = func(7, 6)

add(name, desc, value)[source]#

将对象 value 存储在名称 name 下，并带描述 desc。

返回类型:: ~T

add_def(name, desc)[source]#

返回一个装饰器，该装饰器将装饰的函数存储在名称 name 下，并带描述 desc。

返回类型:: Callable

property names: tuple[str, ...]#

生成所有工厂名称。

返回类型:: tuple[str, …]

排序#

class monai.utils.ordering.Ordering(ordering_type, spatial_dims, dimensions, reflected_spatial_dims=None, transpositions_axes=None, rot90_axes=None, transformation_order=('transpose', 'rotate_90', 'reflect'))[source]#

将 2D 或 3D 图像投影到 1D 序列中的排序类。它还允许图像通过以下变换之一进行变换：反射（详见 np.flip）。转置（详见 np.transpose）。90 度旋转（详见 np.rot90）。

变换按 transformation_order 参数指定的顺序应用。

参数:

ordering_type – 排序类型。以下之一： - ‘raster_scan’：通过从左到右、从上到下扫描图像，将图像投影到 1D 序列中。也称为行主序。 - ‘s_curve’：通过从左上角向右以螺旋形模式扫描图像，向中心弯曲成蛇形图案，将图像投影到 1D 序列中。 - ‘random’：通过随机打乱图像将图像投影到 1D 序列中。
spatial_dims – 图像的空间维度数。
dimensions – 图像的维度。
reflected_spatial_dims – 指示是否沿每个空间维度反射图像的布尔值元组。
transpositions_axes – 指示沿哪些轴转置图像的元组的元组。
rot90_axes – 指示沿哪些轴旋转图像的元组的元组。
transformation_order – 应用变换的顺序。

工具#

配置#

模块 utils#

杂项#

NVTX 注释#

性能分析#

已弃用#

被装饰的可调用对象，当未显式指定已弃用的默认参数时会发出警告。

从其字符串形式（例如，“float32”）获取 torch 数据类型（例如，torch.float32）。

包装一个生成器可调用对象，每当对此类进行迭代时，都会调用该对象并返回其结果。这用于创建一个可以多次迭代给定生成器的迭代器。

list[str]

Jupyter 工具函数#

状态缓存器#

组件存储#

排序#

`list`[`str`]