网络架构#

模块#

ADN#

class monai.networks.blocks.ADN(ordering='NDA', in_channels=None, act='RELU', norm=None, norm_dim=None, dropout=None, dropout_dim=None)[source]#

构建一个包含可选激活 (A)、丢弃 (D) 和归一化 (N) 层并按任意顺序排列的顺序模块

-- (Norm) -- (Dropout) -- (Acti) --

参数:

ordering (str) – 表示激活、丢弃和归一化排序的字符串。默认为 “NDA”。
in_channels (Optional[int, None]) – 预期输入尺寸 (N, C, H[, W, D]) 中的 C。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
norm (Union[tuple, str, None]) – 特征归一化类型及参数。默认为实例归一化。
norm_dim (Optional[int, None]) – 确定归一化层的空间维度。如果未指定，默认为 dropout_dim。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
dropout_dim (Optional[int, None]) –
确定丢弃层的空间维度。如果未指定，默认为 norm_dim。
- 当 dropout_dim = 1 时，随机将每个通道的部分元素置零。
- 当 dropout_dim = 2 时，随机将整个通道置零（通道即为 2D 特征图）。
- 当 dropout_dim = 3 时，随机将整个通道置零（通道即为 3D 特征图）。

示例

# activation, group norm, dropout
>>> norm_params = ("GROUP", {"num_groups": 1, "affine": False})
>>> ADN(norm=norm_params, in_channels=1, dropout_dim=1, dropout=0.8, ordering="AND")
ADN(
    (A): ReLU()
    (N): GroupNorm(1, 1, eps=1e-05, affine=False)
    (D): Dropout(p=0.8, inplace=False)
)

# LeakyReLU, dropout
>>> act_params = ("leakyrelu", {"negative_slope": 0.1, "inplace": True})
>>> ADN(act=act_params, in_channels=1, dropout_dim=1, dropout=0.8, ordering="AD")
ADN(
    (A): LeakyReLU(negative_slope=0.1, inplace=True)
    (D): Dropout(p=0.8, inplace=False)
)

另请参阅

monai.networks.layers.Dropout monai.networks.layers.Act monai.networks.layers.Norm monai.networks.layers.split_args

Convolution#

class monai.networks.blocks.Convolution(spatial_dims, in_channels, out_channels, strides=1, kernel_size=3, adn_ordering='NDA', act='PRELU', norm='INSTANCE', dropout=None, dropout_dim=1, dilation=1, groups=1, bias=True, conv_only=False, is_transposed=False, padding=None, output_padding=None)[source]#

构建一个包含归一化、可选丢弃和可选激活层的卷积模块

-- (Conv|ConvTrans) -- (Norm -- Dropout -- Acti) --

若 conv_only 设为 True

-- (Conv|ConvTrans) --

例如

from monai.networks.blocks import Convolution

conv = Convolution(
    spatial_dims=3,
    in_channels=1,
    out_channels=1,
    adn_ordering="ADN",
    act=("prelu", {"init": 0.2}),
    dropout=0.1,
    norm=("layer", {"normalized_shape": (10, 10, 10)}),
)
print(conv)

输出

Convolution(
  (conv): Conv3d(1, 1, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
  (adn): ADN(
    (A): PReLU(num_parameters=1)
    (D): Dropout(p=0.1, inplace=False)
    (N): LayerNorm((10, 10, 10), eps=1e-05, elementwise_affine=True)
  )
)

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
strides (UnionType[Sequence[int], int]) – 卷积步长。默认为 1。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。默认为 3。
adn_ordering (str) – 表示激活、归一化和丢弃排序的字符串。默认为 “NDA”。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str, None]) – 特征归一化类型及参数。默认为实例归一化。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
dropout_dim (UnionType[int, None]) –
确定丢弃层的空间维度。默认为 1。
- 当 dropout_dim = 1 时，随机将每个通道的部分元素置零。
- 当 dropout_dim = 2 时，随机将整个通道置零（通道即为 2D 特征图）。
- 当 dropout_dim = 3 时，随机将整个通道置零（通道即为 3D 特征图）。
dropout_dim 的值不应大于 spatial_dims 的值。
dilation (UnionType[Sequence[int], int]) – 膨胀率。默认为 1。
groups (int) – 控制输入与输出之间的连接。默认为 1。
bias (bool) – 是否使用偏置项。默认为 True。
conv_only (bool) – 是否仅使用卷积层。默认为 False。
is_transposed (bool) – 若为 True，则使用反卷积（ConvTrans）而非普通卷积（Conv）。默认为 False。
padding (Union[Sequence[int], int, None]) – 控制每个维度两侧的隐式零填充点数。默认为 None。
output_padding (Union[Sequence[int], int, None]) – 控制添加到输出形状一侧的额外大小。默认为 None。

另请参阅

monai.networks.layers.Conv monai.networks.blocks.ADN

CRF#

class monai.networks.blocks.CRF(iterations=5, bilateral_weight=1.0, gaussian_weight=1.0, bilateral_spatial_sigma=5.0, bilateral_color_sigma=0.5, gaussian_spatial_sigma=5.0, update_factor=3.0, compatibility_matrix=None)[source]#

条件随机场 (CRF)：将消息传递与类兼容性卷积相结合，通过迭代过程逐步最小化类标签的能量。

在此实现中，消息传递步骤是高斯滤波器和双边滤波器的加权组合。加入双边项是为了遵循参考张量中已有的结构。

参见: https://arxiv.org/abs/1502.03240

__init__(iterations=5, bilateral_weight=1.0, gaussian_weight=1.0, bilateral_spatial_sigma=5.0, bilateral_color_sigma=0.5, gaussian_spatial_sigma=5.0, update_factor=3.0, compatibility_matrix=None)[source]#

参数:

iterations (int) – 迭代次数。
bilateral_weight (float) – 消息传递步骤中双边项的权重。
gaussian_weight (float) – 消息传递步骤中高斯项的权重。
bilateral_spatial_sigma (float) – 双边项在空间坐标中的标准差。
bilateral_color_sigma (float) – 双边项在颜色空间中的标准差。
gaussian_spatial_sigma (float) – 高斯项在空间坐标中的标准差。
update_factor (float) – 确定每次更新的幅度。
compatibility_matrix (Optional[Tensor, None]) – 描述类兼容性的矩阵，应为 NxN，其中 N 为类数。

forward(input_tensor, reference_tensor)[source]#

参数:

input_tensor (Tensor) – 包含初始类逻辑值的张量。
reference_tensor (Tensor) – 用于引导消息传递的参考张量。

返回:

输出张量。

返回类型:

输出 (torch.Tensor)

ResidualUnit#

class monai.networks.blocks.ResidualUnit(spatial_dims, in_channels, out_channels, strides=1, kernel_size=3, subunits=2, adn_ordering='NDA', act='PRELU', norm='INSTANCE', dropout=None, dropout_dim=1, dilation=1, bias=True, last_conv_only=False, padding=None)[source]#

具有多个卷积和残差连接的残差模块。

例如

from monai.networks.blocks import ResidualUnit

convs = ResidualUnit(
    spatial_dims=3,
    in_channels=1,
    out_channels=1,
    adn_ordering="AN",
    act=("prelu", {"init": 0.2}),
    norm=("layer", {"normalized_shape": (10, 10, 10)}),
)
print(convs)

输出

ResidualUnit(
  (conv): Sequential(
    (unit0): Convolution(
      (conv): Conv3d(1, 1, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
      (adn): ADN(
        (A): PReLU(num_parameters=1)
        (N): LayerNorm((10, 10, 10), eps=1e-05, elementwise_affine=True)
      )
    )
    (unit1): Convolution(
      (conv): Conv3d(1, 1, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
      (adn): ADN(
        (A): PReLU(num_parameters=1)
        (N): LayerNorm((10, 10, 10), eps=1e-05, elementwise_affine=True)
      )
    )
  )
  (residual): Identity()
)

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
strides (UnionType[Sequence[int], int]) – 卷积步长。默认为 1。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。默认为 3。
subunits (int) – 卷积层数。默认为 2。
adn_ordering (str) – 表示激活、归一化和丢弃排序的字符串。默认为 “NDA”。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str, None]) – 特征归一化类型及参数。默认为实例归一化。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
dropout_dim (UnionType[int, None]) –
确定丢弃层的维度。默认为 1。
- 当 dropout_dim = 1 时，随机将每个通道的部分元素置零。
- 当 dropout_dim = 2 时，随机置零整个通道（通道即为 2D 特征图）。
- 当 dropout_dim = 3 时，随机置零整个通道（通道即为 3D 特征图）。
dropout_dim 的值不应大于 dimensions 的值。
dilation (UnionType[Sequence[int], int]) – 膨胀率。默认为 1。
bias (bool) – 是否使用偏置项。默认为 True。
last_conv_only (bool) – 对于最后一个子单元，是否仅使用卷积层。默认为 False。
padding (Union[Sequence[int], int, None]) – 控制每个维度两侧的隐式零填充点数。默认为 None。

另请参阅

monai.networks.blocks.Convolution

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

尽管前向传播的逻辑需要在该函数内定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者负责运行已注册的钩子，而后者会静默忽略它们。

返回类型:: Tensor

Swish#

class monai.networks.blocks.Swish(alpha=1.0)[source]#

应用逐元素函数

\[\text{Swish}(x) = x * \text{Sigmoid}(\alpha * x) ~~~~\text{对于常数}~ \alpha.\]

引用：Searching for Activation Functions, Ramachandran et al., 2017, https://arxiv.org/abs/1710.05941.

形状

输入: \((N, *)\) 其中 * 表示任意数量的附加维度
输出: \((N, *)\)，与输入形状相同

示例

>>> import torch
>>> from monai.networks.layers.factories import Act
>>> m = Act['swish']()
>>> input = torch.randn(2)
>>> output = m(input)

forward(input)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

MemoryEfficientSwish#

class monai.networks.blocks.MemoryEfficientSwish(inplace=False)[source]#

应用逐元素函数

\[\text{Swish}(x) = x * \text{Sigmoid}(\alpha * x) ~~~~\text{对于常数}~ \alpha=1.\]

根据以下建议实现训练时的内存高效版本：lukemelas/EfficientNet-PyTorch#18

与 Swish() 相比，在训练期间可节省约 30% 的内存

引用：Searching for Activation Functions, Ramachandran et al., 2017, https://arxiv.org/abs/1710.05941.

从 Pytorch 1.7.0+ 开始，实现了名为 SiLU 的优化版 Swish，若版本满足要求，此类将使用 torch.nn.functional.silu 进行计算。

形状

输入: \((N, *)\) 其中 * 表示任意数量的附加维度
输出: \((N, *)\)，与输入形状相同

示例

>>> import torch
>>> from monai.networks.layers.factories import Act
>>> m = Act['memswish']()
>>> input = torch.randn(2)
>>> output = m(input)

forward(input)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

FPN#

class monai.networks.blocks.ExtraFPNBlock(*args, **kwargs)[source]#

FPN 中额外块的基类。

代码与 pytorch/vision 相同

forward(results, x, names)[source]#

计算 FPN 的扩展结果集及其名称。

参数:

results (list[Tensor]) – FPN 的结果
x (list[Tensor]) – 原始特征图
names (list[str]) – 每个原始特征图的名称

返回:

FPN 的扩展结果集
结果的扩展名称集

class monai.networks.blocks.FeaturePyramidNetwork(spatial_dims, in_channels_list, out_channels, extra_blocks=None)[source]#

在特征图集合之上添加 FPN 的模块。基于 “Feature Pyramid Network for Object Detection”。

目前假设特征图按深度增加的顺序排列。

模型的输入预期为 OrderedDict[Tensor]，包含将添加 FPN 的特征图。

参数:

spatial_dims (int) – 2D 或 3D 图像
in_channels_list (list[int]) – 传递给模块的每个特征图的通道数
out_channels (int) – FPN 表示的通道数
extra_blocks (Optional[ExtraFPNBlock, None]) – 若提供，将执行额外操作。它预期以 FPN 特征、原始特征和原始特征名称作为输入，并返回一个新的特征图列表及其对应的名称

示例

>>> m = FeaturePyramidNetwork(2, [10, 20, 30], 5)
>>> # get some dummy data
>>> x = OrderedDict()
>>> x['feat0'] = torch.rand(1, 10, 64, 64)
>>> x['feat2'] = torch.rand(1, 20, 16, 16)
>>> x['feat3'] = torch.rand(1, 30, 8, 8)
>>> # compute the FPN on top of x
>>> output = m(x)
>>> print([(k, v.shape) for k, v in output.items()])
>>> # returns
>>>   [('feat0', torch.Size([1, 5, 64, 64])),
>>>    ('feat2', torch.Size([1, 5, 16, 16])),
>>>    ('feat3', torch.Size([1, 5, 8, 8]))]

forward(x)[source]#

计算特征图集的 FPN。

参数:: x (dict[str, Tensor]) – 每个特征级别的特征图。
返回类型:: dict[str, Tensor]
返回:: FPN 层后的特征图。按最高分辨率优先排序。

get_result_from_inner_blocks(x, idx)[source]#

这等同于 self.inner_blocks[idx](x)，但 torchscript 尚不支持此写法

返回类型:: Tensor

get_result_from_layer_blocks(x, idx)[source]#

这等同于 self.layer_blocks[idx](x)，但 torchscript 尚不支持此写法

返回类型:: Tensor

class monai.networks.blocks.LastLevelMaxPool(spatial_dims)[source]#

在最后一个特征图之上应用 max_pool2d 或 max_pool3d。作为 FeaturePyramidNetwork 中的 extra_blocks 使用。

forward(results, x, names)[source]#

计算 FPN 的扩展结果集及其名称。

参数:

results (list[Tensor]) – FPN 的结果
x (list[Tensor]) – 原始特征图
names (list[str]) – 每个原始特征图的名称

返回类型:

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

返回:

FPN 的扩展结果集
结果的扩展名称集

class monai.networks.blocks.LastLevelP6P7(spatial_dims, in_channels, out_channels)[source]#

此模块用于 RetinaNet 生成额外的层 P6 和 P7。作为 FeaturePyramidNetwork 中的 extra_blocks 使用。

forward(results, x, names)[source]#

计算 FPN 的扩展结果集及其名称。

参数:

results (list[Tensor]) – FPN 的结果
x (list[Tensor]) – 原始特征图
names (list[str]) – 每个原始特征图的名称

返回类型:

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

返回:

FPN 的扩展结果集
结果的扩展名称集

class monai.networks.blocks.BackboneWithFPN(backbone, return_layers, in_channels_list, out_channels, spatial_dims=None, extra_blocks=None)[source]#

在模型之上添加 FPN。内部使用 torchvision.models._utils.IntermediateLayerGetter 提取一个子模型，该子模型返回 return_layers 中指定的特征图。IntermediateLayerGetter 的相同限制在此同样适用。

代码与 pytorch/vision 相同，区别在于此类使用了 spatial_dims

参数:

backbone (Module) – 主干网络
return_layers (dict[str, str]) – 一个字典，包含将返回激活值的模块名称作为键，字典的值为返回激活值的名称（用户可指定）。
in_channels_list (list[int]) – 每个返回特征图的通道数，顺序与它们在 OrderedDict 中的顺序一致
out_channels (int) – FPN 中的通道数。
spatial_dims (Optional[int, None]) – 2D 或 3D 图像

forward(x)[source]#

计算网络的生成特征图。

参数:: x (Tensor) – 输入图像
返回类型:: dict[str, Tensor]
返回:: FPN 层后的特征图。按最高分辨率优先排序。

Mish#

class monai.networks.blocks.Mish(inplace=False)[source]#

应用逐元素函数

\[\text{Mish}(x) = x * tanh(\text{softplus}(x)).\]

引用：Mish: A Self Regularized Non-Monotonic Activation Function, Diganta Misra, 2019, https://arxiv.org/abs/1908.08681.

从 Pytorch 1.9.0+ 开始，实现了优化版的 Mish，若版本满足要求，此类将使用 torch.nn.functional.mish 进行计算。

形状

输入: \((N, *)\) 其中 * 表示任意数量的附加维度
输出: \((N, *)\)，与输入形状相同

示例

>>> import torch
>>> from monai.networks.layers.factories import Act
>>> m = Act['mish']()
>>> input = torch.randn(2)
>>> output = m(input)

forward(input)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

GEGLU#

class monai.networks.blocks.GEGLU(*args, **kwargs)[source]#

应用逐元素函数

\[\text{GEGLU}(x) = x_1 * \text{GELU}(x_2)\]

其中 \(x_1\) 和 \(x_2\) 是沿最后一个维度从输入张量拆分得到的。

引用：GLU Variants Improve Transformer, Noam Shazeer, 2020, https://arxiv.org/abs/2002.05202.

形状

输入: \((N, *, 2 * D)\)
输出: \((N, *, D)\)，其中 * 表示任意数量的附加维度

示例

>>> import torch
>>> from monai.networks.layers.factories import Act
>>> m = Act['geglu']()
>>> input = torch.randn(2, 8)  # last dim must be even
>>> output = m(input)

forward(input)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

GCN 模块#

class monai.networks.blocks.GCN(inplanes, planes, ks=7)[source]#

全局卷积网络 (GCN) 模块，使用大型 1D Kx1 和 1xK 核来表示 2D 核。

__init__(inplanes, planes, ks=7)[source]#

参数:

inplanes (int) – 输入通道数。
planes (int) – 输出通道数。
ks (int) – 单个维度的核大小。默认为 7。

forward(x)[source]#

参数:: x (Tensor) – 输入形状 (batch, inplanes, spatial_1, spatial_2)。
返回类型:: Tensor

FCN 模块#

class monai.networks.blocks.FCN(out_channels=1, upsample_mode='bilinear', pretrained=True, progress=True)[source]#

具有 3 个输入通道的 2D FCN 网络。小型解码器由 GCN 和 Refine 模块构建。代码改编自 lsqshr 的官方 2D 代码。

参数:

out_channels (int) – 输出通道数。默认为 1。
upsample_mode (str) –
["transpose", "bilinear"] 上采样操作模式。使用第二种模式无法保证模型的可复现性。默认为 bilinear。
- transpose，使用反卷积层。
- bilinear，使用双线性插值。
pretrained (bool) – 若为 True，则返回在 ImageNet 上预训练的模型
progress (bool) – 若为 True，则在 stderr 中显示下载进度条。

forward(x)[source]#

参数:: x (Tensor) – 输入形状 (batch, 3, spatial_1, spatial_2)。

多通道 FCN 模块#

class monai.networks.blocks.MCFCN(in_channels=3, out_channels=1, upsample_mode='bilinear', pretrained=True, progress=True)[source]#

2D FCN 模块的多通道版本。添加了一个投影层以接收任意数量的输入。

参数:

in_channels (int) – 输入通道数。默认为 3。
out_channels (int) – 输出通道数。默认为 1。
upsample_mode (str) –
["transpose", "bilinear"] 上采样操作模式。使用第二种模式无法保证模型的可复现性。默认为 bilinear。
- transpose，使用反卷积层。
- bilinear，使用双线性插值。
pretrained (bool) – 若为 True，则返回在 ImageNet 上预训练的模型
progress (bool) – 若为 True，则在 stderr 中显示下载进度条。

forward(x)[source]#

参数:: x (Tensor) – 输入形状 (batch, in_channels, spatial_1, spatial_2)。

Dynamic-Unet 模块#

class monai.networks.blocks.UnetResBlock(spatial_dims, in_channels, out_channels, kernel_size, stride, norm_name, act_name=('leakyrelu', {'inplace': True, 'negative_slope': 0.01}), dropout=None)[source]#

一种基于跳跃连接的模块，可用于 DynUNet，基于：Automated Design of Deep Learning Methods for Biomedical Image Segmentation. nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
stride (UnionType[Sequence[int], int]) – 卷积步长。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
act_name (UnionType[tuple, str]) – 激活层类型及参数。
dropout (Union[tuple, str, float, None]) – 丢弃概率。

forward(inp)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

class monai.networks.blocks.UnetBasicBlock(spatial_dims, in_channels, out_channels, kernel_size, stride, norm_name, act_name=('leakyrelu', {'inplace': True, 'negative_slope': 0.01}), dropout=None)[source]#

一种可用于 DynUNet 的 CNN 模块，基于：Automated Design of Deep Learning Methods for Biomedical Image Segmentation. nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
stride (UnionType[Sequence[int], int]) – 卷积步长。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
act_name (UnionType[tuple, str]) – 激活层类型及参数。
dropout (Union[tuple, str, float, None]) – 丢弃概率。

forward(inp)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

class monai.networks.blocks.UnetUpBlock(spatial_dims, in_channels, out_channels, kernel_size, stride, upsample_kernel_size, norm_name, act_name=('leakyrelu', {'inplace': True, 'negative_slope': 0.01}), dropout=None, trans_bias=False)[source]#

一种可用于 DynUNet 的上采样模块，基于：Automated Design of Deep Learning Methods for Biomedical Image Segmentation. nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
stride (UnionType[Sequence[int], int]) – 卷积步长。
upsample_kernel_size (UnionType[Sequence[int], int]) – 反卷积层的卷积核大小。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
act_name (UnionType[tuple, str]) – 激活层类型及参数。
dropout (Union[tuple, str, float, None]) – 丢弃概率。
trans_bias (bool) – 反卷积偏置。

forward(inp, skip)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

class monai.networks.blocks.UnetOutBlock(spatial_dims, in_channels, out_channels, dropout=None)[source]#

forward(inp)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

DenseBlock#

class monai.networks.blocks.DenseBlock(layers)[source]#

DenseBlock 是一系列层，其中每一层的输出与输入进行拼接。这使得前面层的输出可以作为后面层的输入，并作为该模块的最终输出。

参数:: layers (Sequence[Module]) – 定义 DenseBlock 各个层的 nn.Module 对象序列

forward(x)[source]#: 运行前向传播。

SegResnet 模块#

class monai.networks.blocks.ResBlock(spatial_dims, in_channels, norm, kernel_size=3, act=('RELU', {'inplace': True}))[source]#

ResBlock 采用跳跃连接和两个卷积块，用于 SegResNet，基于 3D MRI brain tumor segmentation using autoencoder regularization。

__init__(spatial_dims, in_channels, norm, kernel_size=3, act=('RELU', {'inplace': True}))[source]#

参数:

spatial_dims (int) – 空间维度数量，可为 1、2 或 3。
in_channels (int) – 输入通道数。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。
kernel_size (int) – 卷积核大小，值应为奇数。默认为 3。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 RELU。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

SABlock 模块#

class monai.networks.blocks.SABlock(hidden_size, num_heads, dropout_rate=0.0, qkv_bias=False, save_attn=False, dim_head=None, hidden_input_size=None, causal=False, sequence_length=None, rel_pos_embedding=None, input_size=None, attention_dtype=None, include_fc=True, use_combined_linear=True, use_flash_attention=False)[source]#

自注意力模块，基于：“Dosovitskiy et al., An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>”

__init__(hidden_size, num_heads, dropout_rate=0.0, qkv_bias=False, save_attn=False, dim_head=None, hidden_input_size=None, causal=False, sequence_length=None, rel_pos_embedding=None, input_size=None, attention_dtype=None, include_fc=True, use_combined_linear=True, use_flash_attention=False)[source]#

参数:

hidden_size (int) – 隐藏层维度。
num_heads (int) – 注意力头数。
dropout_rate (float, optional) – 丢弃输入单元的比例。默认为 0.0。
qkv_bias (bool, optional) – qkv 线性层的偏置项。默认为 False。
save_attn (bool, optional) – 是否使注意力矩阵可访问。默认为 False。
dim_head (int, optional) – 每个头的维度。默认为 hidden_size // num_heads。
hidden_input_size (int, optional) – 输入张量的维度。默认为 hidden_size。
causal (bool) – 是否使用因果注意力（参见 https://arxiv.org/abs/1706.03762）。
sequence_length (Optional[int, None]) – 若 causal 为 True，则必须指定序列长度。
rel_pos_embedding (str, optional) – 将相对位置嵌入添加到注意力图。目前仅支持 “decomposed”（参见 https://arxiv.org/abs/2112.01526）。支持 2D 和 3D。
input_size (tuple(spatial_dim), optional) – 用于计算相对位置参数大小的输入分辨率。
attention_dtype (Optional[dtype, None]) – 将注意力操作转换为此数据类型。
include_fc (bool) – 是否包含最终的线性层。默认为 True。
use_combined_linear (bool) – 是否对 qkv 投影使用单个线性层，默认为 True。
use_flash_attention (bool) – 若为 True，则使用 PyTorch 内置的 Flash Attention 以实现内存高效的注意力机制（参见 https://pytorch.ac.cn/docs/2.2/generated/torch.nn.functional.scaled_dot_product_attention.html）。

引发异常:

ValueError – 若 dropout_rate 不在 0 和 1 之间。
ValueError – 若 hidden_size 不能被 num_heads 整除。
ValueError – 若 causal 为 True 且未提供 sequence_length。
ValueError – 若 save_attn 和 use_flash_attention 均为 True。
ValueError – 若 rel_pos_embedding 不为 None 且 use_flash_attention 为 True。

forward(x, attn_mask=None)[source]#

参数:

x (B) – 输入张量。B x (s_dim_1 * … * s_dim_n) x C
attn_mask (torch.Tensor, optional) – 应用于注意力矩阵的掩码。
x

返回:

B x (s_dim_1 * … * s_dim_n) x C

返回类型:

torch.Tensor

CABlock 模块#

class monai.networks.blocks.CABlock(spatial_dims, dim, num_heads, bias, flash_attention=False)[source]#

多维卷积头转置自注意力（MDTA）：与标准自注意力不同，它作用于特征通道而非空间维度。在注意力计算前结合了深度卷积进行局部混合，实现了相比传统注意力机制二次复杂度而言的线性复杂度。基于 SW Zamir 等人，2022 年的研究 <https://arxiv.org/abs/2111.09881>

参数:

spatial_dims – 空间维度数量（2D 或 3D）
dim (int) – 输入通道数
num_heads (int) – 注意力头数
bias (bool) – 卷积层中是否使用偏置
flash_attention (bool) – 是否使用 Flash Attention 优化。默认为 False。

引发异常:

ValueError – 若当前 PyTorch 版本不支持 Flash Attention
ValueError – 若 spatial_dims 大于 3

forward(x)[source]#

MDTA 注意力的前向传播。1. 对 Q、K、V 应用深度卷积 2. 重塑 Q、K、V 以进行多头注意力计算 3. 使用 Flash 或常规注意力计算注意力矩阵 4. 重塑并投影注意力输出

返回类型:: Tensor

前馈模块#

class monai.networks.blocks.FeedForward(spatial_dims, dim, ffn_expansion_factor, bias)[source]#

门控卷积前馈网络（GDFN），通过门控机制控制特征流。使用深度卷积进行局部上下文混合，并使用 GELU 激活的门控进行精细的特征选择。

参数:

spatial_dims (int) – 空间维度数量（2D 或 3D）
dim (int) – 输入通道数
ffn_expansion_factor (float) – 隐藏特征维度扩展因子
bias (bool) – 卷积层中是否使用偏置

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Squeeze-and-Excitation（通道挤压与激励）#

class monai.networks.blocks.ChannelSELayer(spatial_dims, in_channels, r=2, acti_type_1=('relu', {'inplace': True}), acti_type_2='sigmoid', add_residual=False)[source]#

Squeeze-and-Excitation 模块的重新实现，基于：“Hu 等人，Squeeze-and-Excitation Networks，https://arxiv.org/abs/1709.01507”。

__init__(spatial_dims, in_channels, r=2, acti_type_1=('relu', {'inplace': True}), acti_type_2='sigmoid', add_residual=False)[source]#

参数:

spatial_dims (int) – 空间维度数量，可以是 1、2 或 3。
in_channels (int) – 输入通道数。
r (int) – 论文中的缩减比例 r。默认为 2。
acti_type_1 (UnionType[tuple[str, dict], str]) – 隐藏挤压层的激活类型。默认为 ("relu", {"inplace": True})。
acti_type_2 (UnionType[tuple[str, dict], str]) – 输出挤压层的激活类型。默认为 “sigmoid”。

引发异常:

ValueError – 当 r 为非正数或大于 in_channels 时。

另请参阅

monai.networks.layers.Act

forward(x)[source]#

参数:: x (Tensor) – 形状为 (batch, in_channels, spatial_1[, spatial_2, …])。
返回类型:: Tensor

Transformer 模块#

class monai.networks.blocks.TransformerBlock(hidden_size, mlp_dim, num_heads, dropout_rate=0.0, qkv_bias=False, save_attn=False, causal=False, sequence_length=None, with_cross_attention=False, use_flash_attention=False, include_fc=True, use_combined_linear=True)[source]#

Transformer 模块，基于：“Dosovitskiy 等人，An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>”

__init__(hidden_size, mlp_dim, num_heads, dropout_rate=0.0, qkv_bias=False, save_attn=False, causal=False, sequence_length=None, with_cross_attention=False, use_flash_attention=False, include_fc=True, use_combined_linear=True)[source]#

参数:

hidden_size (int) – 隐藏层维度。
mlp_dim (int) – 前馈层的维度。
num_heads (int) – 注意力头数。
dropout_rate (float, optional) – 丢弃输入单元的比例。默认为 0.0。
qkv_bias (bool, optional) – 是否为 qkv 线性层应用偏置项。默认为 False。
save_attn (bool, optional) – 是否使注意力矩阵可访问。默认为 False。
causal (bool, optional) – 是否在自注意力中应用因果掩码。默认为 False。
sequence_length (int | None, optional) – 因果掩码所需的序列长度。默认为 None。
with_cross_attention (bool, optional) – 是否包含对外部上下文张量进行注意力的交叉注意力层。当为 False 时，cross_attn 设置为 nn.Identity()，以便该属性始终存在以供类型检查和检查点兼容性使用。默认为 False。
use_flash_attention (bool) – 若为 True，则使用 PyTorch 内置的 Flash Attention 以实现内存高效的注意力机制（参见 https://pytorch.ac.cn/docs/2.2/generated/torch.nn.functional.scaled_dot_product_attention.html）。
include_fc (bool) – 是否包含最终的线性层。默认为 True。
use_combined_linear (bool) – 是否对 qkv 投影使用单个线性层，默认为 True。

引发异常:

ValueError – 若 dropout_rate 不在 [0, 1] 之间。
ValueError – 若 hidden_size 不能被 num_heads 整除。

forward(x, context=None, attn_mask=None)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

UNETR 模块#

class monai.networks.blocks.UnetrBasicBlock(spatial_dims, in_channels, out_channels, kernel_size, stride, norm_name, res_block=False)[source]#

可用于 UNETR 的 CNN 模块，基于：“Hatamizadeh 等人，UNETR: Transformers for 3D Medical Image Segmentation <https://arxiv.org/abs/2103.10504>”

__init__(spatial_dims, in_channels, out_channels, kernel_size, stride, norm_name, res_block=False)[source]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
stride (UnionType[Sequence[int], int]) – 卷积步长。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
res_block (bool) – 用于确定是否使用残差块的布尔参数。

forward(inp)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

class monai.networks.blocks.UnetrUpBlock(spatial_dims, in_channels, out_channels, kernel_size, upsample_kernel_size, norm_name, res_block=False)[source]#

可用于 UNETR 的上采样模块：“Hatamizadeh 等人，UNETR: Transformers for 3D Medical Image Segmentation <https://arxiv.org/abs/2103.10504>”

__init__(spatial_dims, in_channels, out_channels, kernel_size, upsample_kernel_size, norm_name, res_block=False)[source]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
upsample_kernel_size (UnionType[Sequence[int], int]) – 反卷积层的卷积核大小。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
res_block (bool) – 用于确定是否使用残差块的布尔参数。

forward(inp, skip)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

class monai.networks.blocks.UnetrPrUpBlock(spatial_dims, in_channels, out_channels, num_layer, kernel_size, stride, upsample_kernel_size, norm_name, conv_block=False, res_block=False)[source]#

可用于 UNETR 的投影上采样模块：“Hatamizadeh 等人，UNETR: Transformers for 3D Medical Image Segmentation <https://arxiv.org/abs/2103.10504>”

__init__(spatial_dims, in_channels, out_channels, num_layer, kernel_size, stride, upsample_kernel_size, norm_name, conv_block=False, res_block=False)[source]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
num_layer (int) – 上采样模块的数量。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
stride (UnionType[Sequence[int], int]) – 卷积步长。
upsample_kernel_size (UnionType[Sequence[int], int]) – 反卷积层的卷积核大小。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
conv_block (bool) – 用于确定是否使用卷积块的布尔参数。
res_block (bool) – 用于确定是否使用残差块的布尔参数。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

残差 Squeeze-and-Excitation（通道挤压与激励）#

class monai.networks.blocks.ResidualSELayer(spatial_dims, in_channels, r=2, acti_type_1='leakyrelu', acti_type_2='relu')[source]#

具有残差连接的类“Squeeze-and-Excitation”层

--+-- SE --o--
  |        |
  +--------+

__init__(spatial_dims, in_channels, r=2, acti_type_1='leakyrelu', acti_type_2='relu')[source]#

参数:

spatial_dims (int) – 空间维度数量，可以是 1、2 或 3。
in_channels (int) – 输入通道数。
r (int) – 论文中的缩减比例 r。默认为 2。
acti_type_1 (UnionType[tuple[str, dict], str]) – 默认为 “leakyrelu”。
acti_type_2 (UnionType[tuple[str, dict], str]) – 默认为 “relu”。

另请参阅

monai.networks.blocks.ChannelSELayer

Squeeze-and-Excitation（通道挤压与激励）模块#

class monai.networks.blocks.SEBlock(spatial_dims, in_channels, n_chns_1, n_chns_2, n_chns_3, conv_param_1=None, conv_param_2=None, conv_param_3=None, project=None, r=2, acti_type_1=('relu', {'inplace': True}), acti_type_2='sigmoid', acti_type_final=('relu', {'inplace': True}))[source]#

增强了 Squeeze-and-Excitation 功能的残差模块

----+- conv1 --  conv2 -- conv3 -- SE -o---
    |                                  |
    +---(channel project if needed)----+

SE-Resnet 模块的重新实现，基于：“Hu 等人，Squeeze-and-Excitation Networks，https://arxiv.org/abs/1709.01507”。

__init__(spatial_dims, in_channels, n_chns_1, n_chns_2, n_chns_3, conv_param_1=None, conv_param_2=None, conv_param_3=None, project=None, r=2, acti_type_1=('relu', {'inplace': True}), acti_type_2='sigmoid', acti_type_final=('relu', {'inplace': True}))[source]#

参数:

spatial_dims (int) – 空间维度数量，可以是 1、2 或 3。
in_channels (int) – 输入通道数。
n_chns_1 (int) – 第 1 次卷积的输出通道数。
n_chns_2 (int) – 第 2 次卷积的输出通道数。
n_chns_3 (int) – 第 3 次卷积的输出通道数。
conv_param_1 (Optional[dict, None]) – 第 1 次卷积的附加参数。默认为 {"kernel_size": 1, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}
conv_param_2 (Optional[dict, None]) – 第 2 次卷积的附加参数。默认为 {"kernel_size": 3, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}
conv_param_3 (Optional[dict, None]) – 第 3 次卷积的附加参数。默认为 {"kernel_size": 1, "norm": Norm.BATCH, "act": None}
project (Optional[Convolution, None]) – 当残差通道数与输出通道数不匹配时，使用投影（Conv）层/模块来调整通道数。在 SENET 中，它同样包含卷积层和归一化层。默认为 None（通道数匹配）或卷积核大小为 1 的卷积层。
r (int) – 论文中的缩减比例 r。默认为 2。
acti_type_1 (UnionType[tuple[str, dict], str]) – 隐藏挤压层的激活类型。默认为 “relu”。
acti_type_2 (UnionType[tuple[str, dict], str]) – 输出挤压层的激活类型。默认为 “sigmoid”。
acti_type_final (UnionType[tuple[str, dict], str, None]) – 模块末尾的激活类型。默认为 “relu”。

另请参阅

monai.networks.blocks.ChannelSELayer

forward(x)[source]#

参数:: x (Tensor) – 形状为 (batch, in_channels, spatial_1[, spatial_2, …])。
返回类型:: Tensor

Squeeze-and-Excitation 瓶颈（Bottleneck）#

class monai.networks.blocks.SEBottleneck(spatial_dims, inplanes, planes, groups, reduction, stride=1, downsample=None)[source]#: SENet154 的瓶颈结构。

Squeeze-and-Excitation Resnet 瓶颈#

class monai.networks.blocks.SEResNetBottleneck(spatial_dims, inplanes, planes, groups, reduction, stride=1, downsample=None)[source]#: 带有 Squeeze-and-Excitation 模块的 ResNet 瓶颈。它遵循 Caffe 的实现，在 conv1 中使用 strides=stride 而非 conv2（后者用于 torchvision 的 ResNet 实现）。

Squeeze-and-Excitation ResNeXt 瓶颈#

class monai.networks.blocks.SEResNeXtBottleneck(spatial_dims, inplanes, planes, groups, reduction, stride=1, downsample=None, base_width=4)[source]#: 带有 Squeeze-and-Excitation 模块的 ResNeXt C 类瓶颈。

简单 ASPP#

class monai.networks.blocks.SimpleASPP(spatial_dims, in_channels, conv_out_channels, kernel_sizes=(1, 3, 3, 3), dilations=(1, 2, 4, 6), norm_type='BATCH', acti_type='LEAKYRELU', bias=False)[source]#

Atrous 空间金字塔池化（ASPP）模块的简化版本。

Chen 等人，Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation. https://arxiv.org/abs/1802.02611

Wang 等人，A Noise-robust Framework for Automatic Segmentation of COVID-19 Pneumonia Lesions from CT Images. https://ieeexplore.ieee.org/document/9109297

__init__(spatial_dims, in_channels, conv_out_channels, kernel_sizes=(1, 3, 3, 3), dilations=(1, 2, 4, 6), norm_type='BATCH', acti_type='LEAKYRELU', bias=False)[source]#

参数:

spatial_dims (int) – 空间维度数量，可以是 1、2 或 3。
in_channels (int) – 输入通道数。
conv_out_channels (int) – 每个空洞卷积的输出通道数。最终输出通道数为 conv_out_channels * len(kernel_sizes)。
kernel_sizes (Sequence[int]) – 四个卷积核大小的序列。对于四个（空洞）卷积，默认为 (1, 3, 3, 3)。
dilations (Sequence[int]) – 四个卷积空洞参数的序列。对于四个（空洞）卷积，默认为 (1, 2, 4, 6)。
norm_type (UnionType[tuple, str, None]) – 最终核大小为 1 的卷积归一化类型。默认为批归一化。
acti_type (UnionType[tuple, str, None]) – 最终核大小为 1 的卷积激活类型。默认为 leaky ReLU。
bias (bool) – 卷积块中是否包含偏置项。默认为 False。根据性能调优指南，如果卷积层后直接跟随批归一化层，bias 应为 False。

引发异常:

ValueError – 当 kernel_sizes 的长度与 dilations 不同时。

另请参阅

monai.networks.layers.Act monai.networks.layers.Conv monai.networks.layers.Norm

forward(x)[source]#

参数:: x (Tensor) – 形状为 (batch, channel, spatial_1[, spatial_2, …])。
返回类型:: Tensor

最大-平均池化#

class monai.networks.blocks.MaxAvgPool(spatial_dims, kernel_size, stride=None, padding=0, ceil_mode=False)[source]#

同时使用最大池化和平均池化进行下采样，通过拼接下采样后的特征图将通道数加倍。

__init__(spatial_dims, kernel_size, stride=None, padding=0, ceil_mode=False)[source]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。
kernel_size (UnionType[Sequence[int], int]) – 两种池化操作的核大小。
stride (Union[Sequence[int], int, None]) – 窗口的步长。默认值为 kernel_size。
padding (UnionType[Sequence[int], int]) – 应用于两种池化操作的隐式零填充。
ceil_mode (bool) – 当为 True 时，将使用 ceil 而不是 floor 来计算输出形状。

forward(x)[source]#

参数:: x (Tensor) – 形状为 (batch, channel, spatial_1[, spatial_2, …]) 的张量。
返回类型:: Tensor
返回:: 形状为 (batch, 2*channel, spatial_1[, spatial_2, …]) 的张量。

上采样#

class monai.networks.blocks.UpSample(spatial_dims, in_channels=None, out_channels=None, scale_factor=2, kernel_size=None, size=None, mode=deconv, pre_conv='default', post_conv=None, interp_mode=linear, align_corners=True, bias=True, apply_pad_pool=True)[source]#

按 scale_factor 上采样数据。支持的模式有

“deconv”：使用转置卷积。

“deconvgroup”：使用转置分组卷积。

“nontrainable”：使用 torch.nn.Upsample。

“pixelshuffle”：使用 monai.networks.blocks.SubpixelUpsample。

当 mode 为 UpsampleMode.NONTRAINABLE 时，该操作会导致非确定性。请查看以下链接了解更多详细信息：https://pytorch.ac.cn/docs/stable/generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms 此模块可以选择包含一个预卷积（通常用于将特征数量从 in_channels 映射到 out_channels）。

__init__(spatial_dims, in_channels=None, out_channels=None, scale_factor=2, kernel_size=None, size=None, mode=deconv, pre_conv='default', post_conv=None, interp_mode=linear, align_corners=True, bias=True, apply_pad_pool=True)[source]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (Optional[int, None]) – 输入图像的通道数。
out_channels (Optional[int, None]) – 输出图像的通道数。默认为 in_channels。
scale_factor (UnionType[Sequence[float], float]) – 空间大小的乘数。如果是元组，必须与输入大小匹配。默认为 2。
kernel_size (Union[float, Sequence[float], None]) – 转置卷积期间使用的核大小。默认为 scale_factor。
size (Union[tuple[int], int, None]) – 输出图像的空间大小。仅当 mode 为 UpsampleMode.NONTRAINABLE 时使用。在 torch.nn.functional.interpolate 中，size 或 scale_factor 应该只定义一个，因此如果定义了 size，则不会使用 scale_factor。默认为 None。
mode (UnionType[UpsampleMode, str]) – {"deconv", "deconvgroup", "nontrainable", "pixelshuffle"}。默认为 "deconv"。
pre_conv (UnionType[Module, str, None]) – 上采样前应用的卷积块。默认为 “default”。当 conv_block 为 "default" 时，仅在 “nontrainable” 或 “pixelshuffle” 模式下使用一个预留的卷积层。
post_conv (Optional[Module, None]) – 上采样后应用的卷积块。默认为 None。仅在 “nontrainable” 模式下使用。
interp_mode (str) – {"nearest", "linear", "bilinear", "bicubic", "trilinear"} 仅在 “nontrainable” 模式下使用。如果以 "linear" 结尾，将使用 spatial dims 来确定正确的插值方式。这分别对应于 1D、2D 和 3D 的 linear、bilinear、trilinear 插值。插值模式。默认为 "linear"。另请参见：https://pytorch.ac.cn/docs/stable/generated/torch.nn.Upsample.html
align_corners (UnionType[bool, None]) – 设置 torch.nn.Upsample 的 align_corners 参数。默认为 True。仅在 “nontrainable” 模式下使用。
bias (bool) – 默认 preconv 和 deconv 层中是否包含偏置项。默认为 True。
apply_pad_pool (bool) – 若为 True，则对上采样后的张量进行填充，然后应用核大小为 scale_factor、步长为 1 的平均池化。另请参见：monai.networks.blocks.SubpixelUpsample。仅在 “pixelshuffle” 模式下使用。

引发异常:

ValueError – 若 mode 为 "deconv" 或 "deconvgroup" 且未指定 in_channels。
ValueError – 若 mode 为 "nontrainable"，未设置 pre_conv，且 out_channels != in_channels。

monai.networks.blocks.Upsample[source]#: UpSample 的别名

class monai.networks.blocks.SubpixelUpsample(spatial_dims, in_channels, out_channels=None, scale_factor=2, conv_block='default', apply_pad_pool=True, bias=True)[源码]#

通过使用子像素 CNN 进行上采样。该模块支持 1D、2D 和 3D 输入图像。该模块由两部分组成。首先，使用卷积层将通道数增加到：in_channels * (scale_factor ** dimensions)。其次，利用像素重排（pixel shuffle）操作来聚合来自低分辨率空间的特征图，并构建超分辨率空间。该模块的第一部分不是固定的，可以使用顺序层（sequential layers）来替换默认的单层。

参考：Shi 等人，2016 年，“利用高效子像素卷积神经网络进行实时单图像和视频超分辨率”。

参考：Aitken 等人，2017 年，“无棋盘格伪影的子像素卷积”。

该思想源自：https://arxiv.org/abs/1609.05158

像素重排机制参考：https://pytorch.ac.cn/docs/stable/generated/torch.nn.PixelShuffle.html#torch.nn.PixelShuffle 以及：pytorch/pytorch#6340。

__init__(spatial_dims, in_channels, out_channels=None, scale_factor=2, conv_block='default', apply_pad_pool=True, bias=True)[源码]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (UnionType[int, None]) – 输入图像的通道数。
out_channels (Optional[int, None]) – 输出图像的可选通道数。
scale_factor (int) – 空间尺寸的乘数。默认为 2。
conv_block (UnionType[Module, str, None]) –
用于在上采样前提取特征图的卷积块。默认为 None。
- 当 conv_block 为 "default" 时，将使用一个预留的卷积层。
- 当 conv_block 为 nn.module 时，请确保输出通道数可被 (scale_factor ** dimensions) 整除。
apply_pad_pool (bool) – 如果为 True，则对上采样后的张量进行填充，然后应用核大小为 scale_factor、步长为 1 的平均池化。这实现了 Aitken 等人描述的子像素卷积中的最近邻调整卷积组件。
bias (bool) – 默认卷积块中是否包含偏置项。默认为 True。

forward(x)[源码]#

参数:: x (Tensor) – 形状为 (batch, channel, spatial_1[, spatial_2, …) 的张量。
返回类型:: Tensor

monai.networks.blocks.Subpixelupsample[源码]#: SubpixelUpsample 的别名

monai.networks.blocks.SubpixelUpSample[源码]#: SubpixelUpsample 的别名

下采样 (Downsampling)#

class monai.networks.blocks.DownSample(spatial_dims, in_channels=None, out_channels=None, scale_factor=2, kernel_size=None, mode=conv, pre_conv='default', post_conv=None, bias=True)[源码]#

通过 scale_factor 下采样数据。

支持的模式包括

“conv”：使用步长卷积进行可学习的下采样。
“convgroup”：使用分组步长卷积进行高效的特征缩减。
“nontrainable”：使用带有反向缩放因子的 torch.nn.Upsample。
“pixelunshuffle”：使用 monai.networks.blocks.PixelUnshuffle 进行通道空间重排。

当 mode 为 DownsampleMode.NONTRAINABLE 时，该操作会导致非确定性行为。请查阅以下链接了解更多详细信息：https://pytorch.ac.cn/docs/stable/generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms

该模块可选地接受预卷积（常用于将特征数量从 in_channels 映射到 out_channels）。

__init__(spatial_dims, in_channels=None, out_channels=None, scale_factor=2, kernel_size=None, mode=conv, pre_conv='default', post_conv=None, bias=True)[源码]#

通过 scale_factor 下采样数据。支持的模式包括

DownsampleMode.CONV：使用步长卷积进行可学习的下采样。

DownsampleMode.CONVGROUP：使用分组步长卷积进行高效的特征缩减。

DownsampleMode.MAXPOOL：使用最大池化进行不可学习的下采样。

DownsampleMode.AVGPOOL：使用平均池化进行不可学习的下采样。

DownsampleMode.PIXELUNSHUFFLE：使用 monai.networks.blocks.SubpixelDownsample。

该模块可选地接受预卷积和后卷积（常用于将特征数量从 in_channels 映射到 out_channels）。

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (Optional[int, None]) – 输入图像的通道数。
out_channels (Optional[int, None]) – 输出图像的通道数。默认为 in_channels。
scale_factor (UnionType[Sequence[float], float]) – 空间尺寸缩减的乘数。如果是元组，则必须与输入尺寸匹配。默认为 2。
kernel_size (Union[float, Sequence[float], None]) – 卷积期间使用的核大小。默认为 scale_factor。
mode (UnionType[DownsampleMode, str]) – {DownsampleMode.CONV, DownsampleMode.CONVGROUP, DownsampleMode.MAXPOOL, DownsampleMode.AVGPOOL, DownsampleMode.PIXELUNSHUFFLE}。默认为 DownsampleMode.CONV。
pre_conv (UnionType[Module, str, None]) – 下采样前应用的卷积块。默认为 “default”。当 conv_block 为 "default" 时，将使用一个预留的卷积层。仅在 “maxpool”、“avgpool” 或 “pixelunshuffle” 模式下使用。
post_conv (Optional[Module, None]) – 下采样后应用的卷积块。默认为 None。仅在 “maxpool” 和 “avgpool” 模式下使用。
bias (bool) – 默认预卷积层和卷积层中是否包含偏置项。默认为 True。

引发异常:

ValueError – 如果 mode 为 "conv" 或 "convgroup" 且未指定 in_channels。
ValueError – 如果 mode 为 "maxpool" 或 "avgpool"，pre_conv 为 "default"，out_channels != in_channels，且未指定 in_channels。

monai.networks.blocks.Downsample[源码]#: DownSample 的别名

class monai.networks.blocks.SubpixelDownsample(spatial_dims, in_channels, out_channels=None, scale_factor=2, conv_block='default', bias=True)[源码]#

通过使用子像素 CNN 进行下采样。该模块支持 1D、2D 和 3D 输入图像。该模块由两部分组成。首先，使用卷积层来调整通道数。其次，像素反重排（pixel unshuffle）操作将空间信息重新排列到通道空间中，从而在增加通道深度的同时有效减少空间维度。

像素反重排操作是像素重排的逆操作，将 2D 图像的维度从 (B, C, H*r, W*r) 重新排列为 (B, C*r², H, W)，或者在 3D 情况下从 (B, C, H*r, W*r, D*r) 重新排列为 (B, C*r³, H, W, D)。

示例：r=2 时，(1, 1, 4, 4) 变为 (1, 4, 2, 2)。

参考：Shi 等人，2016 年，“利用高效子像素卷积神经网络进行实时单图像和视频超分辨率”。

像素反重排机制是以下操作的逆操作：Project-MONAI/MONAI

__init__(spatial_dims, in_channels, out_channels=None, scale_factor=2, conv_block='default', bias=True)[源码]#

通过将空间信息重新排列到通道空间来下采样数据。这在增加通道深度的同时减少了空间维度。

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (UnionType[int, None]) – 输入图像的通道数。
out_channels (Optional[int, None]) – 输出图像的可选通道数。
scale_factor (int) – 减少空间维度的因子。默认为 2。
conv_block (UnionType[Module, str, None]) – 下采样前用于调整通道的卷积块。默认为 None。当 conv_block 为 "default" 时，将使用一个预留的卷积层。当 conv_block 为 nn.module 时，请确保输入通道数符合要求。
bias (bool) – 默认卷积块中是否包含偏置项。默认为 True。

引发异常:

ValueError – 如果 scale_factor 不大于 0。
ValueError – 如果 conv_block 为 "default" 且未指定 in_channels。

forward(x)[源码]#

参数:: x (Tensor) – 形状为 (batch, channel, spatial_1[, spatial_2, …) 的张量。
返回类型:: Tensor
返回:: 空间维度减少且通道深度增加的张量。

monai.networks.blocks.Subpixeldownsample[源码]#: SubpixelDownsample 的别名

monai.networks.blocks.SubpixelDownSample[源码]#: SubpixelDownsample 的别名

注册残差卷积块 (Registration Residual Conv Block)#

class monai.networks.blocks.RegistrationResidualConvBlock(spatial_dims, in_channels, out_channels, num_layers=2, kernel_size=3)[源码]#

一个带有跳跃连接和层归一化-激活的块。仅改变通道数，空间尺寸保持不变。

__init__(spatial_dims, in_channels, out_channels, num_layers=2, kernel_size=3)[源码]#

参数:

spatial_dims (int) – 空间维度的数量
in_channels (int) – 输入通道的数量
out_channels (int) – 输出通道的数量
num_layers (int) – 块内的层数
kernel_size (int) – 核大小

forward(x)[源码]#

参数:: x (Tensor) – 形状为 (batch, in_channels, insize_1, insize_2, [insize_3]) 的张量
返回类型:: Tensor
返回:: 形状为 (batch, out_channels, insize_1, insize_2, [insize_3]) 的张量，具有与 x 相同的空间尺寸

注册下采样块 (Registration Down Sample Block)#

class monai.networks.blocks.RegistrationDownSampleBlock(spatial_dims, channels, pooling)[源码]#

RegUNet 中使用的下采样模块，用于将空间尺寸减半。通道数保持不变。

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, channels, pooling)[源码]#

参数:

spatial_dims (int) – 空间维度数量。
channels (int) – 通道数
pooling (bool) – 若为 True 则使用 MaxPool，若为 False 则使用步长卷积

forward(x)[源码]#

将空间维度减半并保持相同的通道数。输出形状为 (batch, channels, insize_1 / 2, insize_2 / 2, [insize_3 / 2])

参数:: x (Tensor) – 形状为 (batch, channels, insize_1, insize_2, [insize_3]) 的张量
引发异常:: ValueError – 当输入空间维度不是偶数时。
返回类型:: Tensor

注册提取块 (Registration Extraction Block)#

class monai.networks.blocks.RegistrationExtractionBlock(spatial_dims, extract_levels, num_channels, out_channels, kernel_initializer='kaiming_uniform', activation=None, mode='nearest', align_corners=None)[源码]#

RegUNet 中使用的提取块。从每个 extract_levels 中提取特征并取平均值。

__init__(spatial_dims, extract_levels, num_channels, out_channels, kernel_initializer='kaiming_uniform', activation=None, mode='nearest', align_corners=None)[源码]#

参数:

spatial_dims (int) – 空间维度的数量
extract_levels (tuple[int]) – 要提取特征的空间级别，0 指输入尺度
num_channels (UnionType[tuple[int], list[int]]) – 每个尺度级别的通道数，列表或元组长度等于 RegNet 的 depth
out_channels (int) – 输出通道的数量
kernel_initializer (UnionType[str, None]) – 核初始化器
activation (Optional[str, None]) – 核激活函数
mode (str) – 特征图插值模式，默认为 “nearest”。
align_corners (Optional[bool, None]) – 是否对齐特征图插值的角点。

forward(x, image_size)[源码]#

参数:

x (list[Tensor]) – 不同空间级别的解码特征，从深到浅排序
image_size (list[int]) – 输出图像大小

返回类型:

Tensor

返回:

形状为 (batch, out_channels, size1, size2, size3) 的张量，其中 (size1, size2, size3) = image_size

LocalNet 下采样块 (LocalNet DownSample Block)#

class monai.networks.blocks.LocalNetDownSampleBlock(spatial_dims, in_channels, out_channels, kernel_size)[源码]#

一个可用于 LocalNet 的下采样模块，基于：用于多模态图像注册的弱监督卷积神经网络。用于多模态可变形图像注册的标签驱动弱监督学习。

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, in_channels, out_channels, kernel_size)[源码]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。

引发异常:

NotImplementedError – 当 kernel_size 为偶数时

forward(x)[源码]#

将空间维度减半。返回一个 (x, mid) 的元组

x 是下采样结果，形状为 (batch, out_channels, insize_1 / 2, insize_2 / 2, [insize_3 / 2])

mid 是中间层特征，形状为 (batch, out_channels, insize_1, insize_2, [insize_3])

参数:: x – 形状为 (batch, in_channels, insize_1, insize_2, [insize_3]) 的张量
引发异常:: ValueError – 当输入空间维度不是偶数时。
返回类型:: tuple[Tensor, Tensor]

LocalNet 上采样块 (LocalNet UpSample Block)#

class monai.networks.blocks.LocalNetUpSampleBlock(spatial_dims, in_channels, out_channels, mode='nearest', align_corners=None)[源码]#

一个可用于 LocalNet 的上采样模块，基于：用于多模态图像注册的弱监督卷积神经网络。用于多模态可变形图像注册的标签驱动弱监督学习。

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, in_channels, out_channels, mode='nearest', align_corners=None)[源码]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
mode (str) – 加性上采样的插值模式，默认为 ‘nearest’。
align_corners (Optional[bool, None]) – 是否对加性上采样进行角点对齐，默认为 None。

引发异常:

ValueError – 当 in_channels != 2 * out_channels 时

forward(x, mid)[源码]#

减半通道数并加倍空间维度。

参数:

x – 待上采样的特征，形状为 (batch, in_channels, insize_1, insize_2, [insize_3])
mid – 下采样期间保存的中间层特征，形状为 (batch, out_channels, midsize_1, midsize_2, [midsize_3])

引发异常:

ValueError – 当 midsize != insize * 2 时

返回类型:

Tensor

LocalNet 特征提取块 (LocalNet Feature Extractor Block)#

class monai.networks.blocks.LocalNetFeatureExtractorBlock(spatial_dims, in_channels, out_channels, act='RELU', initializer='kaiming_uniform')[源码]#

一个可用于 LocalNet 的特征提取模块，基于：用于多模态图像注册的弱监督卷积神经网络。用于多模态可变形图像注册的标签驱动弱监督学习。

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, in_channels, out_channels, act='RELU', initializer='kaiming_uniform')[源码]#

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
act (UnionType[tuple, str, None]) – 激活类型和参数。默认为 ReLU。
initializer (str) – 核初始化器，可以是 "kaiming_uniform" 或 "zeros"。默认为 "kaiming_uniform"。注意："kaiming_uniform" 内部使用 nn.init.kaiming_normal_。

引发异常:

ValueError – 如果 initializer 不是 "kaiming_uniform" 或 "zeros"。

forward(x)[源码]#

参数:: x – 形状为 (batch, in_channels, insize_1, insize_2, [insize_3]) 的张量
返回类型:: Tensor

MLP 块 (MLP Block)#

class monai.networks.blocks.MLPBlock(hidden_size, mlp_dim, dropout_rate=0.0, act='GELU', dropout_mode='vit')[源码]#

多层感知机块，基于：“Dosovitskiy 等人，图像胜过 16x16 单词：大规模图像识别的 Transformer <https://arxiv.org/abs/2010.11929>”

__init__(hidden_size, mlp_dim, dropout_rate=0.0, act='GELU', dropout_mode='vit')[源码]#

参数:

hidden_size (int) – 隐藏层的维度。
mlp_dim (int) – 前馈层的维度。如果为 0，则使用 hidden_size。
dropout_rate (float) – 要丢弃的输入单元的比例。
act (UnionType[tuple, str]) – 激活类型和参数。默认为 GELU。也支持 “GEGLU” 等。
dropout_mode – Dropout 模式，可以是 “vit” 或 “swin”。“vit” 模式使用两个 Dropout 实例，如 google-research/vision_transformer 中实现；“swin” 对应于一个实例，如 microsoft/Swin-Transformer 中实现；“vista3d” 模式不使用 Dropout。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

Patch 嵌入块 (Patch Embedding Block)#

class monai.networks.blocks.PatchEmbeddingBlock(in_channels, img_size, patch_size, hidden_size, num_heads, proj_type='conv', pos_embed_type='learnable', dropout_rate=0.0, spatial_dims=3, pos_embed_kwargs=None)[源码]#

Patch 嵌入块，基于：“Dosovitskiy 等人，图像胜过 16x16 单词：大规模图像识别的 Transformer <https://arxiv.org/abs/2010.11929>”

示例

>>> from monai.networks.blocks import PatchEmbeddingBlock
>>> PatchEmbeddingBlock(in_channels=4, img_size=32, patch_size=8, hidden_size=32, num_heads=4,
>>>                     proj_type="conv", pos_embed_type="sincos")

__init__(in_channels, img_size, patch_size, hidden_size, num_heads, proj_type='conv', pos_embed_type='learnable', dropout_rate=0.0, spatial_dims=3, pos_embed_kwargs=None)[源码]#

参数:

in_channels (int) – 输入通道的维度。
img_size (UnionType[Sequence[int], int]) – 输入图像的维度。
patch_size (UnionType[Sequence[int], int]) – Patch 大小的维度。
hidden_size (int) – 隐藏层的维度。
num_heads (int) – 注意力头的数量。
proj_type (str) – Patch 嵌入层类型。
pos_embed_type (str) – 位置嵌入层类型。
dropout_rate (float) – 要丢弃的输入单元的比例。
spatial_dims (int) – 空间维度数量。
pos_embed_kwargs (Optional[dict, None]) – 位置嵌入的附加参数。对于 sincos，可以包含 temperature；对于 fourier，可以包含 scales。

引发异常:

ValueError – 若 dropout_rate 不在 0 和 1 之间。
ValueError – 若 hidden_size 不能被 num_heads 整除。
ValueError – 如果 patch_size 的任何维度大于相应的 img_size 维度。
ValueError – 如果 proj_type 为 "perceptron" 且 patch_size 不能整除 img_size。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

因子化增加块 (FactorizedIncreaseBlock)#

class monai.networks.blocks.FactorizedIncreaseBlock(in_channel, out_channel, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

使用线性插值和卷积将特征上采样两倍。

__init__(in_channel, out_channel, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

参数:

in_channel (int) – 输入通道数
out_channel (int) – 输出通道数
spatial_dims (int) – 空间维度的数量
act_name (UnionType[tuple, str]) – 激活层类型及参数。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。

因子化减少块 (FactorizedReduceBlock)#

class monai.networks.blocks.FactorizedReduceBlock(in_channel, out_channel, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

使用步长将特征下采样 2 倍。每个空间维度上的长度必须是 2 的倍数。

__init__(in_channel, out_channel, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

参数:

in_channel (int) – 输入通道数
out_channel (int) – 输出通道数。
spatial_dims (int) – 空间维度数量。
act_name (UnionType[tuple, str]) – 激活层类型及参数。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。

forward(x)[源码]#

每个空间维度上的长度必须是 2 的倍数。

返回类型:: Tensor

P3DActiConvNormBlock#

class monai.networks.blocks.P3DActiConvNormBlock(in_channel, out_channel, kernel_size, padding, mode=0, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

– (激活) – (卷积) – (归一化) –

__init__(in_channel, out_channel, kernel_size, padding, mode=0, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

参数:

in_channel (int) – 输入通道数。
out_channel (int) – 输出通道数。
kernel_size (int) – 待扩展至 3D 的卷积核大小。
padding (int) – 待扩展至 3D 的填充大小。
mode (int) –
各向异性卷积核的模式
- 0: (k, k, 1), (1, 1, k),
- 1: (k, 1, k), (1, k, 1),
- 2: (1, k, k). (k, 1, 1).
act_name (UnionType[tuple, str]) – 激活层类型及参数。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。

ActiConvNormBlock#

class monai.networks.blocks.ActiConvNormBlock(in_channel, out_channel, kernel_size=3, padding=1, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

– (激活) – (卷积) – (归一化) –

__init__(in_channel, out_channel, kernel_size=3, padding=1, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}))[源码]#

参数:

in_channel (int) – 输入通道数。
out_channel (int) – 输出通道数。
kernel_size (int) – 卷积核大小。
padding (int) – 卷积填充大小。
spatial_dims (int) – 空间维度数量。
act_name (UnionType[tuple, str]) – 激活层类型及参数。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。

Warp#

class monai.networks.blocks.Warp(mode='bilinear', padding_mode='border', jitter=False)[源码]#

利用给定的稠密位移场 (DDF) 对图像进行扭曲（Warp）。

__init__(mode='bilinear', padding_mode='border', jitter=False)[源码]#

对于 Pytorch 原生 API，可选值为

mode: "nearest", "bilinear", "bicubic"。

padding_mode: "zeros", "border", "reflection"

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

对于 MONAI C++/CUDA 扩展，可选值为

mode: "nearest", "bilinear", "bicubic", 0, 1, …

padding_mode: "zeros", "border", "reflection", 0, 1, …

另请参阅: monai.networks.layers.grid_pull

jitter: bool, 默认=False
定义非整数值上的参考网格。参考: B. Likar and F. Pernus. A heirarchical approach to elastic registration based on mutual information. Image and Vision Computing, 19:33-44, 2001.

注意，使用 mode="nearest" 会使扭曲操作在效果上不可导：梯度几乎处处为零，这可能会在训练期间阻碍梯度传播。对于基于学习的配准，请改用 "bilinear" (2D) 或 "trilinear" (3D) 插值。

请参阅 Project-MONAI/tutorials 获取使用分割进行半监督配准的示例。

forward(image, ddf)[源码]#

参数:

image (Tensor) – 形状为 (batch, num_channels, H, W[, D]) 的张量
ddf (Tensor) – 与图像空间大小相同的张量，形状为 (batch, spatial_dims, H, W[, D])

返回:

与图像形状相同的 warped_image (batch, num_channels, H, W[, D])

DVF2DDF#

class monai.networks.blocks.DVF2DDF(num_steps=7, mode='bilinear', padding_mode='zeros')[源码]#

层，通过缩放与平方（scaling and squaring）方法从稠密速度场（DVF）计算稠密位移场（DDF）。

改编自: DeepReg (DeepRegNet/DeepReg)

forward(dvf)[源码]#

参数:: dvf (Tensor) – 待转换的 dvf，形状为 (batch, spatial_dims, H, W[,D])
返回类型:: Tensor
返回:: 稠密位移场

VarNetBlock#

class monai.apps.reconstruction.networks.blocks.varnetblock.VarNetBlock(refinement_model, spatial_dims=2)[源码]#

基于 Sriram 等人论文“End-to-end variational networks for accelerated MRI reconstruction”的变分块。它对中间 k 空间应用数据一致性（data consistency）和细化，并将结果进行合并。

修改并采用自: facebookresearch/fastMRI

参数:

refinement_model (Module) – 用于细化的模型（通常为 U-Net，但可以是任何在输入和输出均位于图像域时表现良好的深度学习模型，例如卷积网络）。
spatial_dims (int) – 2D 数据为 2，3D 数据为 3

forward(current_kspace, ref_kspace, mask, sens_maps)[源码]#

参数:

current_kspace (Tensor) – 前一个块预测的 k 空间。它是 2D k 空间 (B,C,H,W,2)，最后一个维度为 2（用于实部/虚部），C 表示线圈维度。3D 数据形状为 (B,C,H,W,D,2)。
ref_kspace (Tensor) – 用于应用数据一致性的参考 k 空间（MRI 重建中的欠采样 k 空间）。其形状与 current_kspace 相同。
mask (Tensor) – 欠采样掩码，2D 数据形状为 (1,1,1,W,1)，3D 数据形状为 (1,1,1,1,D,1)。
sens_maps (Tensor) – 线圈敏感度图，形状与 current_kspace 相同

返回类型:

Tensor

返回:

VarNetBlock 的输出，形状与 current_kspace 相同

soft_dc(x, ref_kspace, mask)[源码]#

将数据一致性应用于输入 x。假设 x 是 k 空间的中间估计值，ref_kspace 是参考欠采样测量值。此函数返回 mask * (x - ref_kspace)。将其视为原始欠采样 k 空间与网络给出的估计值之间的残差。

参数:

x (Tensor) – 2D k 空间 (B,C,H,W,2)，最后一个维度为 2（用于实部/虚部），C 表示线圈维度。3D 数据形状为 (B,C,H,W,D,2)。
ref_kspace (Tensor) – 形状与 x 相同的原始欠采样 k 空间。
mask (Tensor) – 欠采样掩码，2D 数据形状为 (1,1,1,W,1)，3D 数据形状为 (1,1,1,1,D,1)。

返回类型:

Tensor

返回:

DC 块的输出，形状与 x 相同

N 维傅里叶变换#

monai.networks.blocks.fft_utils_t.fftn_centered_t(im, spatial_dims, is_complex=True)[源码]#

基于 Pytorch 的 spatial_dims 维信号 fft。“Centered”意味着此函数自动处理所需的 ifft 和 fft 移位。这等同于基于 numpy.fft.fftn, numpy.fft.fftshift 和 numpy.fft.ifftshift 在 numpy 中执行 ifft

参数:

im (Tensor) – 图像，可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
spatial_dims (int) – 空间维数（例如，图像为 2，体积为 3）
is_complex (bool) – 如果为 True，则预期输入 im 的最后一个维度为 2（代表实部和虚部通道）

返回类型:

Tensor

返回:

“out”，即输出的 k 空间（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.networks.blocks.fft_utils_t.ifftn_centered_t(ksp, spatial_dims, is_complex=True)[源码]#

基于 Pytorch 的 spatial_dims 维信号 ifft。“Centered”意味着此函数自动处理所需的 ifft 和 fft 移位。这等同于基于 numpy.fft.ifftn, numpy.fft.fftshift 和 numpy.fft.ifftshift 在 numpy 中执行 fft

参数:

ksp (Tensor) – k 空间数据，可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
spatial_dims (int) – 空间维数（例如，图像为 2，体积为 3）
is_complex (bool) – 如果为 True，则预期输入 ksp 的最后一个维度为 2（代表实部和虚部通道）

返回类型:

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)

monai.networks.blocks.fft_utils_t.roll(x, shift, shift_dims)[源码]#

类似于 np.roll，但应用于 PyTorch 张量

参数:

x (Tensor) – 输入数据（k 空间或图像），可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
shift (list[int]) – 沿每个 shift_dims 维度的移位量
shift_dims (list[int]) – 应用移位的维度

返回类型:

Tensor

返回:

x 的移位版本

monai.networks.blocks.fft_utils_t.roll_1d(x, shift, shift_dim)[源码]#

类似于 roll，但仅针对一个维度。

参数:

x (Tensor) – 输入数据（k 空间或图像），可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
shift (int) – 沿每个 shift_dims 维度的移位量
shift_dim (int) – 应用移位的维度

返回类型:

Tensor

返回:

x 的 1d 移位版本

monai.networks.blocks.fft_utils_t.fftshift(x, shift_dims)[源码]#

类似于 np.fft.fftshift，但应用于 PyTorch 张量

参数:

x (Tensor) – 输入数据（k 空间或图像），可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
shift_dims (list[int]) – 应用移位的维度

返回类型:

Tensor

返回:

x 的 fft 移位版本

monai.networks.blocks.fft_utils_t.ifftshift(x, shift_dims)[源码]#

类似于 np.fft.ifftshift，但应用于 PyTorch 张量

参数:

x (Tensor) – 输入数据（k 空间或图像），可以是 1) 实数值：形状为 (C,H,W)（2D 空间输入）或 (C,H,W,D)（3D），或者 2) 复数值：形状为 (C,H,W,2)（2D 空间数据）或 (C,H,W,D,2)（3D）。C 为通道数。
shift_dims (list[int]) – 应用移位的维度

返回类型:

Tensor

返回:

x 的 ifft 移位版本

层#

工厂 (Factories)#

定义用于以通用、可扩展且与维度无关的方式创建层的工厂。为每种类型的层创建一个单独的工厂对象，并向这些对象添加以名称为键的工厂函数。每当请求一个层时，工厂名称和任何必要的参数都会传递给工厂对象。返回值通常是一个类型，但也可以是任何产生层对象的 callable。

工厂对象包含以转换为大写的名称为键的函数，这些名称可以作为工厂的成员被引用，从而作为常量标识符使用。例如，实例归一化被命名为 Norm.INSTANCE。

例如，要获取转置卷积层，需要该名称，然后提供一个维度参数，该参数会被传递给工厂函数

dimension = 3
name = Conv.CONVTRANS
conv = Conv[name, dimension]

这允许在构造函数中设置维度值，例如以便网络的维度是可参数化的。并非所有工厂都需要名称后的参数，调用者必须了解哪些是必需的。

定义新工厂涉及创建对象，然后将其与工厂函数关联

fact = LayerFactory()

@fact.factory_function('test')
def make_something(x, y):
    # do something with x and y to choose which layer type to return
    return SomeLayerType
...

# request object from factory TEST with 1 and 2 as values for x and y
layer = fact[fact.TEST, 1, 2]

通常工厂的调用者会知道要传递什么参数（即请求类型的维度），但可以通过工厂名称和在实例化时传递给创建类型的参数来进行参数化

def use_factory(fact_args):
    fact_name, type_args = split_args
    layer_type = fact[fact_name, 1, 2]
    return layer_type(**type_args)
...

kw_args = {'arg0':0, 'arg1':True}
layer = use_factory( (fact.TEST, kwargs) )

class monai.networks.layers.LayerFactory(name, description)[源码]#

用于创建层的工厂对象，它使用给定的工厂函数来实际生产类型或构造 callables。这些函数按名称引用，并可在任何时候添加。

add_factory_callable(name, func, desc=None)[源码]#

在此对象下以给定名称添加工厂函数，并带有可选说明。

返回类型:: None

add_factory_class(name, cls, desc=None)[源码]#

添加一个工厂函数，该函数在给定名称下返回提供的类，并带有可选说明。

返回类型:: None

factory_function(name)[源码]#

用于添加具有给定名称的工厂函数的装饰器。

返回类型:: Callable（可调用对象）

get_constructor(factory_name, *args)[源码]#

获取给定工厂名称和参数的构造函数。

引发异常:: TypeError – 当 factory_name 不是 str 时。
返回类型:: Any

split_args#

monai.networks.layers.split_args(args)[源码]#

以适合与工厂类型一起使用的方式分割参数。如果 args 是一个字符串，它被解释为类型名称。

参数:: args (str 或 对象名称与 kwargs 字典的元组) – 待解析的输入参数。
引发异常:: TypeError – 当 args 类型不在 Union[str, Tuple[Union[str, Callable], dict]] 中时。

示例

>>> act_type, args = split_args("PRELU")
>>> monai.networks.layers.Act[act_type]
<class 'torch.nn.modules.activation.PReLU'>

>>> act_type, args = split_args(("PRELU", {"num_parameters": 1, "init": 0.25}))
>>> monai.networks.layers.Act[act_type](**args)
PReLU(num_parameters=1)

Dropout#

层工厂 ‘Dropout layers’：用于创建 Dropout 层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: dropout, alphadropout

Act#

层工厂 ‘Activation layers’：用于创建激活层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: elu, relu, leakyrelu, prelu, relu6, selu, celu, gelu, sigmoid, tanh, softmax, logsoftmax, swish, memswish, mish, geglu

Norm#

层工厂 ‘Normalization layers’：用于创建归一化层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: instance, batch, instance_nvfuser, group, layer, localresponse, syncbatch

Conv#

层工厂 ‘Convolution layers’：用于创建卷积层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: conv, convtrans

Pad#

层工厂 ‘Padding layers’：用于创建填充层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: replicationpad, constantpad

Pool#

层工厂 ‘Pooling layers’：用于创建池化层的工厂。请参阅 monai.networks.layers.split_args 获取更多参数解析说明。

支持的成员有: max, adaptivemax, avg, adaptiveavg

ChannelPad#

class monai.networks.layers.ChannelPad(spatial_dims, in_channels, out_channels, mode=pad)[源码]#

通过填充或投影，将输入张量的通道维度长度从 in_channels 扩展至 out_channels。

__init__(spatial_dims, in_channels, out_channels, mode=pad)[源码]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
mode (UnionType[ChannelMatching, str]) –
{"pad", "project"} 指定处理残差分支和卷积分支通道不匹配的情况。默认为 "pad"。
- "pad": 使用零填充。
- "project": 使用内核大小为 1 的可训练卷积。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

SkipConnection#

class monai.networks.layers.SkipConnection(submodule, dim=1, mode='cat')[源码]#

将前向传播输入与来自给定子模块的结果相结合

--+--submodule--o--
  |_____________|

可用模式有 "cat", "add", "mul"。

__init__(submodule, dim=1, mode='cat')[源码]#

参数:

submodule – 定义可训练分支的模块。
dim (int) – 张量拼接的维度。当模式为 "cat" 时使用。
mode (UnionType[str, SkipMode]) – "cat", "add", "mul"。默认为 "cat"。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Flatten#

class monai.networks.layers.Flatten(*args, **kwargs)[源码]#

在前向传播中将给定的输入展平为 [B, -1] 形状。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Reshape#

class monai.networks.layers.Reshape(*shape)[源码]#

将输入张量重塑（reshape）为给定形状（减去批次维度），同时保留原始批次大小。

__init__(*shape)[源码]#

给定整数形状列表/元组 shape (s0, s1, … , sn)，该层将形状为 (batch, s0 * s1 * … * sn) 的输入张量重塑为形状 (batch, s0, s1, … , sn)。

参数:: shape (int) – 整数形状维度的列表/元组

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

separable_filtering#

monai.networks.layers.separable_filtering(x, kernels, mode='zeros')[源码]#

沿 x 的每个空间维度应用 1-D 卷积。

参数:

x (Tensor) – 输入图像。必须具有形状 (batch, channels, H[, W, …])。
kernels (list[Tensor]) – 沿每个空间维度的卷积核。可以是一个单个卷积核（对所有空间维度重复使用），或者是包含 spatial_dims 数量卷积核的列表。
mode (string, 可选) – 传递给卷积类的填充模式。'zeros', 'reflect', 'replicate' 或 'circular'。默认: 'zeros'。更多信息请参阅 torch.nn.Conv1d()。

引发异常:

TypeError – 当 x 不是 torch.Tensor 时。

示例

>>> import torch
>>> from monai.networks.layers import separable_filtering
>>> img = torch.randn(2, 4, 32, 32)  # batch_size 2, channels 4, 32x32 2D images
# applying a [-1, 0, 1] filter along each of the spatial dimensions.
# the output shape is the same as the input shape.
>>> out = separable_filtering(img, torch.tensor((-1., 0., 1.)))
# applying `[-1, 0, 1]`, `[1, 0, -1]` filters along two spatial dimensions respectively.
# the output shape is the same as the input shape.
>>> out = separable_filtering(img, [torch.tensor((-1., 0., 1.)), torch.tensor((1., 0., -1.))])

返回类型:: Tensor

apply_filter#

monai.networks.layers.apply_filter(x, kernel, **kwargs)[源码]#

针对每个批次和通道分别使用 kernel 对 x 进行过滤。

参数:

x (Tensor) – 输入图像，必须具有形状 (batch, channels, H[, W, D])。
kernel (Tensor) – kernel 必须至少具有空间形状 (H_k[, W_k, D_k])。kernel 形状必须能够广播到 x 的 batch 和 channels 维度。
kwargs – 传递给 conv*d() 函数的关键字参数。

返回类型:

Tensor

返回:

过滤后的 x。

示例

>>> import torch
>>> from monai.networks.layers import apply_filter
>>> img = torch.rand(2, 5, 10, 10)  # batch_size 2, channels 5, 10x10 2D images
>>> out = apply_filter(img, torch.rand(3, 3))   # spatial kernel
>>> out = apply_filter(img, torch.rand(5, 3, 3))  # channel-wise kernels
>>> out = apply_filter(img, torch.rand(2, 5, 3, 3))  # batch-, channel-wise kernels

GaussianFilter#

class monai.networks.layers.GaussianFilter(spatial_dims, sigma, truncated=4.0, approx='erf', requires_grad=False)[源码]#

__init__(spatial_dims, sigma, truncated=4.0, approx='erf', requires_grad=False)[源码]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。必须具有形状 (Batch, channels, H[, W, …])。
sigma (UnionType[Sequence[float], float, Sequence[Tensor], Tensor]) – 标准差。可以是一个单个值，或 spatial_dims 数量的值。
truncated (float) – 截断多少个标准差。
approx (str) –
离散高斯核类型，可用选项为“erf”、“sampled”和“scalespace”。
- erf 近似法通过误差函数进行插值；
- sampled 使用采样的高斯核；
- scalespace 对应于基于改进贝塞尔函数（modified Bessel functions）的 https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel。
requires_grad (bool) – 是否存储 sigma 的梯度。如果为 True，sigma 将作为该模块参数的初始值（例如，可以使用 parameters() 迭代器获取参数）；否则该模块将使用 sigma 作为标准差固定核。

forward(x)[源码]#

参数:: x (Tensor) – 形状为 [Batch, chns, H, W, D]。
返回类型:: Tensor

MedianFilter#

class monai.networks.layers.MedianFilter(radius, spatial_dims=3, device='cpu')[源码]#

将中值滤波器应用于图像。

参数:: radius (UnionType[Sequence[int], int]) – 模糊核半径（当 spatial_dims=3 时，半径为 1 对应 3x3x3 的核）。
返回:: 过滤后的输入张量。

示例

>>> from monai.networks.layers import MedianFilter
>>> import torch
>>> in_tensor = torch.rand(4, 5, 7, 6)
>>> blur = MedianFilter([1, 1, 1])  # 3x3x3 kernel
>>> output = blur(in_tensor)
>>> output.shape
torch.Size([4, 5, 7, 6])

forward(in_tensor, number_of_passes=1)[源码]#

参数:

in_tensor (Tensor) – 输入张量，中值滤波将应用于最后 spatial_dims 个维度。
number_of_passes – 中值滤波将重复执行的次数

返回类型:

Tensor

median_filter#

class monai.networks.layers.median_filter(in_tensor, kernel_size=(3, 3, 3), spatial_dims=3, kernel=None, **kwargs)[源码]#

将中值滤波器应用于图像。

参数:

in_tensor (Tensor) – 输入张量；中值滤波将应用于最后 spatial_dims 个维度。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
spatial_dims (int) – 应用中值滤波的空间维度数量。
kernel (Optional[Tensor, None]) – 可选的自定义卷积核。
kwargs – conv 的附加参数。

返回类型:

Tensor

返回:

过滤后的输入张量，形状与 in_tensor 保持不变

示例

>>> from monai.networks.layers import median_filter
>>> import torch
>>> x = torch.rand(4, 5, 7, 6)
>>> output = median_filter(x, (3, 3, 3))
>>> output.shape
torch.Size([4, 5, 7, 6])

BilateralFilter#

class monai.networks.layers.BilateralFilter(*args, **kwargs)[源码]#

在空间上对输入张量进行模糊处理，同时保留边缘。可以运行在 1D、2D 或 3D 张量上（在 Batch 和 Channel 维度之上）。提供了两种实现：一种是精确解，另一种是使用置换网格（permutohedral lattice）的快速近似解。

参见: https://en.wikipedia.org/wiki/Bilateral_filter https://graphics.stanford.edu/papers/permutohedral/

参数:

input – 输入张量。
spatial_sigma – 空间模糊的标准差。当不使用近似方法（参见快速近似）时，较高的值可能会影响性能。
color_sigma – 颜色模糊的标准差。较低的值可以更好地保留边缘，而较高的值倾向于简单的空间高斯模糊。
approx (fast) – 此标志用于选择两种实现方式之一。近似方法在某些场景下可能会产生伪影，而精确解对于较高的空间标准差可能会慢到无法忍受。

返回:

输出张量。

返回类型:

输出 (torch.Tensor)

static backward(ctx, grad_output)[源码]#: 自动求导反向传播

static forward(ctx, input, spatial_sigma=5, color_sigma=0.5, fast_approx=True)[源码]#: 自动求导前向传播

TrainableBilateralFilter#

class monai.networks.layers.TrainableBilateralFilter(spatial_sigma, color_sigma)[源码]#

相应出版物中提出的可训练双边滤波器层的实现。所有滤波器参数都可以进行数据驱动训练。空间滤波器核 x、y 和 z 决定图像平滑度，而颜色参数指定边缘保留程度。可以运行在 1D、2D 或 3D 张量上（在 Batch 和 Channel 维度之上）。

参见: F. Wagner, et al., Ultralow-parameter denoising: Trainable bilateral filter layers in computed tomography, Medical Physics (2022), https://doi.org/10.1002/mp.15718

参数:

input – 待过滤的输入张量。
spatial_sigma – 初始化空间滤波器核的可训练标准差的元组 (sigma_x, sigma_y, sigma_z)。元组长度必须等于输入空间维度的数量。
color_sigma – 强度范围核的可训练标准差。此滤波器参数决定边缘保留的程度。

返回:

过滤后的张量。

返回类型:

输出 (torch.Tensor)

forward(input_tensor)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

TrainableJointBilateralFilter#

class monai.networks.layers.TrainableJointBilateralFilter(spatial_sigma, color_sigma)[源码]#

相应出版物中提出的可训练联合双边滤波器层的实现。引导图像（guidance image）在过滤期间用作附加（边缘）信息。所有滤波器参数和引导图像都可以进行数据驱动训练。空间滤波器核 x、y 和 z 决定图像平滑度，而颜色参数指定边缘保留程度。可以运行在 1D、2D 或 3D 张量上（在 Batch 和 Channel 维度之上）。输入张量形状必须与引导张量形状匹配。

参见: F. Wagner, et al., Trainable joint bilateral filters for enhanced prediction stability in low-dose CT, Scientific Reports (2022), https://doi.org/10.1038/s41598-022-22530-4

参数:

input – 待过滤的输入张量。
guide – 过滤期间使用的引导图像张量。
spatial_sigma – 初始化空间滤波器核的可训练标准差的元组 (sigma_x, sigma_y, sigma_z)。元组长度必须等于输入空间维度的数量。
color_sigma – 强度范围核的可训练标准差。此滤波器参数决定边缘保留的程度。

返回:

过滤后的张量。

返回类型:

输出 (torch.Tensor)

forward(input_tensor, guidance_tensor)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

PHLFilter#

class monai.networks.layers.PHLFilter(*args, **kwargs)[源码]#

基于任意特征向量过滤输入。使用置换格（permutohedral lattice）数据结构来高效近似 n 维高斯滤波。其复杂度大致与核大小无关。最适用于更高维度的滤波和更大的核尺寸。

参见: https://graphics.stanford.edu/papers/permutohedral/

参数:

input – 待过滤的输入张量。
features – 用于过滤输入的特征张量。
sigmas – 滤波器中每个特征的标准差。

返回:

输出张量。

返回类型:

输出 (torch.Tensor)

GaussianMixtureModel#

class monai.networks.layers.GaussianMixtureModel(channel_count, mixture_count, mixture_size, verbose_build=False)[source]#

采用初始标记，并使用高斯混合模型来近似特征空间中每一类的分布。然后，根据每个未标记元素对每一类近似分布的拟合程度，为其分配属于该类的概率。

参见: https://en.wikipedia.org/wiki/Mixture_model

SavitzkyGolayFilter#

class monai.networks.layers.SavitzkyGolayFilter(window_length, order, axis=2, mode='zeros')[source]#

使用 Savitzky-Golay 核沿特定轴对张量进行卷积。

参数:

window_length (int) – 滤波器窗口的长度，必须为正奇数。
order (int) – 每个窗口拟合的多项式阶数，必须小于 window_length。
axis (optional) – 应用滤波器核的轴。默认为 2（第一个空间维度）。
mode (string, optional) – 传递给卷积类的填充模式。可选 'zeros'、'reflect'、'replicate' 或
Default ('circular'.) – 'zeros'。更多信息请参阅 torch.nn.Conv1d()。

forward(x)[source]#

参数:: x (Tensor) – 要过滤的张量或类数组对象。必须是实数，形状为 [Batch, chns, spatial1, spatial2, ...]，且设备类型必须为 'cpu'。
返回:: x 经过 Savitzky-Golay 核过滤，窗口长度为 self.window_length，使用阶数为 self.order 的多项式，沿 self.axis 指定的轴进行。
返回类型:: torch.Tensor

HilbertTransform#

class monai.networks.layers.HilbertTransform(axis=2, n=None)[source]#

确定沿特定轴的张量的解析信号。

参数:

axis (int) – 应用希尔伯特变换的轴。默认为 2（第一个空间维度）。
n (Optional[int, None]) – 傅里叶分量数量（即 FFT 大小）。默认为 x.shape[axis]。

forward(x)[source]#

参数:: x (Tensor) – 要变换的张量或类数组对象。必须是实数，且形状为 [Batch, chns, spatial1, spatial2, ...]。
返回:: x 的解析信号，沿 self.axis 指定的轴变换，使用大小为 self.N 的 FFT。x_ht 的绝对值与 x 沿 self.axis 轴的包络相关。
返回类型:: torch.Tensor

Affine Transform#

class monai.networks.layers.AffineTransform(spatial_size=None, normalized=False, mode=bilinear, padding_mode=zeros, align_corners=True, reverse_indexing=True, zero_centered=None)[source]#

__init__(spatial_size=None, normalized=False, mode=bilinear, padding_mode=zeros, align_corners=True, reverse_indexing=True, zero_centered=None)[source]#

使用仿射矩阵批次应用仿射变换。

当 normalized=False 且 reverse_indexing=True 时，它按照 scipy.ndimage.affine_transform 的约定执行常用的“拉取（pull）”方向重采样。在这种情况下，theta 等同于 scipy.ndimage.affine_transform 的 (ndim+1, ndim+1) 输入 矩阵，在齐次坐标上操作。另请参阅：https://docs.scipy.org.cn/doc/scipy/reference/generated/scipy.ndimage.affine_transform.html

当 normalized=True 且 reverse_indexing=False 时，它直接将 theta 应用于归一化坐标（坐标范围在 [-1, 1] 之间）。这通常与 align_corners=False 一起使用，以实现与分辨率无关的重采样，因此作为空间变换网络等可训练模块的一部分非常有用。另请参阅：https://pytorch.ac.cn/tutorials/intermediate/spatial_transformer_tutorial.html

参数:

spatial_size (Union[Sequence[int], int, None]) – 输出空间形状，完整的输出形状将为 [N, C, *spatial_size]，其中 N 和 C 从 self.forward 的 src 输入推断得出。
normalized (bool) – 指示提供的仿射矩阵 theta 是否为归一化坐标定义的。如果 normalized=False，theta 将被转换为在归一化坐标上操作，因为 pytorch 的 affine_grid 在归一化坐标上工作。
mode (str) – {"bilinear", "nearest"} 用于计算输出值的插值模式。默认为 "bilinear"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html
padding_mode (str) – {"zeros", "border", "reflection"} 外部网格值的填充模式。默认为 "zeros"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html
align_corners (bool) – 另请参阅 https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html。
reverse_indexing (bool) – 是否反转图像和坐标的空间索引。如果 theta 遵循 pytorch 默认的“D, H, W”约定，则设置为 False。如果 theta 遵循 scipy.ndimage 默认的“i, j, k”约定，则设置为 True。
zero_centered (Optional[bool, None]) – 仿射是否应用于零中心值范围内的坐标。当 zero_centered=True 时，例如旋转中心将是输入的空间中心；当 zero_centered=False 时，旋转中心将是输入的原点。此选项仅在 normalized=False 时可用，未指定时的默认行为为 False。另请参阅：monai.networks.utils.normalize_transform()。

forward(src, theta, spatial_size=None)[source]#

theta 必须是仿射变换矩阵，空间 2D 变换为 3x3 或 Nx3x3 或 Nx2x3 或 2x3，空间 3D 变换为 4x4 或 Nx4x4 或 Nx3x4 或 3x4，其中 N 为批次大小。theta 将转换为浮点张量以进行计算。

参数:

src (array_like) – 空间 2D 或 3D 图像 (N, C, spatial_dims)，其中 N 为批次维度，C 为通道数。
theta (array_like) – 空间 2D 输入为 Nx3x3, Nx2x3, 3x3, 2x3；空间 3D 输入为 Nx4x4, Nx3x4, 3x4, 4x4。当省略批次维度时，theta 将被重复 N 次，N 为 src 的批次维度。
spatial_size (Union[Sequence[int], int, None]) – 输出空间形状，完整的输出形状将为 [N, C, *spatial_size]，其中 N 和 C 从 src 推断得出。

引发异常:

TypeError – 当 theta 不是 torch.Tensor 时。
ValueError – 当 theta 不是 [Nxdxd, dxd] 之一时。
ValueError – 当 theta 不是 [Nx3x3, Nx4x4] 之一时。
TypeError – 当 src 不是 torch.Tensor 时。
ValueError – 当 src 的空间维度不是 [2D, 3D] 之一时。
ValueError – 当仿射和图像的批次维度不同时。

返回类型:

Tensor

grid_pull#

monai.networks.layers.grid_pull(input, grid, interpolation='linear', bound='zero', extrapolate=True)[source]#

根据变形场对图像进行采样。

interpolation 可以是 int、string 或 InterpolationType。可能的值有

- 0 or 'nearest'    or InterpolationType.nearest
- 1 or 'linear'     or InterpolationType.linear
- 2 or 'quadratic'  or InterpolationType.quadratic
- 3 or 'cubic'      or InterpolationType.cubic
- 4 or 'fourth'     or InterpolationType.fourth
- 5 or 'fifth'      or InterpolationType.fifth
- 6 or 'sixth'      or InterpolationType.sixth
- 7 or 'seventh'    or InterpolationType.seventh

可以按 [W, H, D] 的顺序提供一系列值，以指定特定于维度的插值阶数。

bound 可以是 int、string 或 BoundType。可能的值有

- 0 or 'replicate' or 'nearest'      or BoundType.replicate or 'border'
- 1 or 'dct1'      or 'mirror'       or BoundType.dct1
- 2 or 'dct2'      or 'reflect'      or BoundType.dct2
- 3 or 'dst1'      or 'antimirror'   or BoundType.dst1
- 4 or 'dst2'      or 'antireflect'  or BoundType.dst2
- 5 or 'dft'       or 'wrap'         or BoundType.dft
- 7 or 'zero'      or 'zeros'        or BoundType.zero

可以按 [W, H, D] 的顺序提供一系列值，以指定特定于维度的边界条件。sliding 是一种仅适用于流场（具有与维度相同数量的通道）的特殊条件。它不能是特定于维度的。注意：

dft 对应于循环填充

dct2 对应于诺伊曼（Neumann）边界条件（对称）

dst2 对应于狄利克雷（Dirichlet）边界条件（反对称）

另请参阅

https://en.wikipedia.org/wiki/Discrete_cosine_transform
https://en.wikipedia.org/wiki/Discrete_sine_transform
help(monai._C.BoundType)
help(monai._C.InterpolationType)

参数:

input (Tensor) – 输入图像。(B, C, Wi, Hi, Di)。
grid (Tensor) – 变形场。(B, Wo, Ho, Do, 1|2|3)。
interpolation (int or list[int] , optional) – 插值阶数。默认为 ‘linear’。
bound (BoundType, or list[BoundType], optional) – 边界条件。默认为 ‘zero’。
extrapolate (bool) – 外推越界数据。默认为 True。

返回:

变形后的图像 (B, C, Wo, Ho, Do)。

返回类型:

输出 (torch.Tensor)

grid_push#

monai.networks.layers.grid_push(input, grid, shape=None, interpolation='linear', bound='zero', extrapolate=True)[source]#

根据变形场对图像进行泼溅（splat）（拉取的伴随操作）。

interpolation 可以是 int、string 或 InterpolationType。可能的值有

- 0 or 'nearest'    or InterpolationType.nearest
- 1 or 'linear'     or InterpolationType.linear
- 2 or 'quadratic'  or InterpolationType.quadratic
- 3 or 'cubic'      or InterpolationType.cubic
- 4 or 'fourth'     or InterpolationType.fourth
- 5 or 'fifth'      or InterpolationType.fifth
- 6 or 'sixth'      or InterpolationType.sixth
- 7 or 'seventh'    or InterpolationType.seventh

可以按 [W, H, D] 的顺序提供一系列值，以指定特定于维度的插值阶数。

bound 可以是 int、string 或 BoundType。可能的值有

- 0 or 'replicate' or 'nearest'      or BoundType.replicate
- 1 or 'dct1'      or 'mirror'       or BoundType.dct1
- 2 or 'dct2'      or 'reflect'      or BoundType.dct2
- 3 or 'dst1'      or 'antimirror'   or BoundType.dst1
- 4 or 'dst2'      or 'antireflect'  or BoundType.dst2
- 5 or 'dft'       or 'wrap'         or BoundType.dft
- 7 or 'zero'                        or BoundType.zero

dft 对应于循环填充

dct2 对应于诺伊曼（Neumann）边界条件（对称）

dst2 对应于狄利克雷（Dirichlet）边界条件（反对称）

另请参阅

https://en.wikipedia.org/wiki/Discrete_cosine_transform
https://en.wikipedia.org/wiki/Discrete_sine_transform
help(monai._C.BoundType)
help(monai._C.InterpolationType)

参数:

input (Tensor) – 输入图像 (B, C, Wi, Hi, Di)。
grid (Tensor) – 变形场 (B, Wi, Hi, Di, 1|2|3)。
shape – 源图像的形状。
interpolation (int or list[int] , optional) – 插值阶数。默认为 ‘linear’。
bound (BoundType, or list[BoundType], optional) – 边界条件。默认为 ‘zero’。
extrapolate (bool) – 外推越界数据。默认为 True。

返回:

泼溅后的图像 (B, C, Wo, Ho, Do)。

返回类型:

输出 (torch.Tensor)

grid_count#

monai.networks.layers.grid_count(grid, shape=None, interpolation='linear', bound='zero', extrapolate=True)[source]#

根据变形场进行泼溅权重（拉取的伴随操作）。

此函数等效于将 grid_push 应用于全 1 的图像。

interpolation 可以是 int、string 或 InterpolationType。可能的值有

- 0 or 'nearest'    or InterpolationType.nearest
- 1 or 'linear'     or InterpolationType.linear
- 2 or 'quadratic'  or InterpolationType.quadratic
- 3 or 'cubic'      or InterpolationType.cubic
- 4 or 'fourth'     or InterpolationType.fourth
- 5 or 'fifth'      or InterpolationType.fifth
- 6 or 'sixth'      or InterpolationType.sixth
- 7 or 'seventh'    or InterpolationType.seventh

可以按 [W, H, D] 的顺序提供一系列值，以指定特定于维度的插值阶数。

bound 可以是 int、string 或 BoundType。可能的值有

- 0 or 'replicate' or 'nearest'      or BoundType.replicate
- 1 or 'dct1'      or 'mirror'       or BoundType.dct1
- 2 or 'dct2'      or 'reflect'      or BoundType.dct2
- 3 or 'dst1'      or 'antimirror'   or BoundType.dst1
- 4 or 'dst2'      or 'antireflect'  or BoundType.dst2
- 5 or 'dft'       or 'wrap'         or BoundType.dft
- 7 or 'zero'                        or BoundType.zero

dft 对应于循环填充

dct2 对应于诺伊曼（Neumann）边界条件（对称）

dst2 对应于狄利克雷（Dirichlet）边界条件（反对称）

另请参阅

https://en.wikipedia.org/wiki/Discrete_cosine_transform
https://en.wikipedia.org/wiki/Discrete_sine_transform
help(monai._C.BoundType)
help(monai._C.InterpolationType)

参数:

grid (Tensor) – 变形场 (B, Wi, Hi, Di, 2|3)。
shape – 源图像的形状。
interpolation (int or list[int] , optional) – 插值阶数。默认为 ‘linear’。
bound (BoundType, or list[BoundType], optional) – 边界条件。默认为 ‘zero’。
extrapolate (bool, optional) – 外推越界数据。默认为 True。

返回:

泼溅权重 (B, 1, Wo, Ho, Do)。

返回类型:

输出 (torch.Tensor)

grid_grad#

monai.networks.layers.grid_grad(input, grid, interpolation='linear', bound='zero', extrapolate=True)[source]#

根据变形场对图像进行采样。

interpolation 可以是 int、string 或 InterpolationType。可能的值有

- 0 or 'nearest'    or InterpolationType.nearest
- 1 or 'linear'     or InterpolationType.linear
- 2 or 'quadratic'  or InterpolationType.quadratic
- 3 or 'cubic'      or InterpolationType.cubic
- 4 or 'fourth'     or InterpolationType.fourth
- 5 or 'fifth'      or InterpolationType.fifth
- 6 or 'sixth'      or InterpolationType.sixth
- 7 or 'seventh'    or InterpolationType.seventh

可以按 [W, H, D] 的顺序提供一系列值，以指定特定于维度的插值阶数。

bound 可以是 int、string 或 BoundType。可能的值有

- 0 or 'replicate' or 'nearest'      or BoundType.replicate
- 1 or 'dct1'      or 'mirror'       or BoundType.dct1
- 2 or 'dct2'      or 'reflect'      or BoundType.dct2
- 3 or 'dst1'      or 'antimirror'   or BoundType.dst1
- 4 or 'dst2'      or 'antireflect'  or BoundType.dst2
- 5 or 'dft'       or 'wrap'         or BoundType.dft
- 7 or 'zero'                        or BoundType.zero

dft 对应于循环填充

dct2 对应于诺伊曼（Neumann）边界条件（对称）

dst2 对应于狄利克雷（Dirichlet）边界条件（反对称）

另请参阅

https://en.wikipedia.org/wiki/Discrete_cosine_transform
https://en.wikipedia.org/wiki/Discrete_sine_transform
help(monai._C.BoundType)
help(monai._C.InterpolationType)

参数:

input (Tensor) – 输入图像。(B, C, Wi, Hi, Di)。
grid (Tensor) – 变形场。(B, Wo, Ho, Do, 2|3)。
interpolation (int or list[int] , optional) – 插值阶数。默认为 ‘linear’。
bound (BoundType, or list[BoundType], optional) – 边界条件。默认为 ‘zero’。
extrapolate (bool) – 外推越界数据。默认为 True。

返回:

采样的梯度 (B, C, Wo, Ho, Do, 1|2|3)。

返回类型:

输出 (torch.Tensor)

LLTM#

class monai.networks.layers.LLTM(input_features, state_size)[source]#

该循环单元类似于 LSTM，但区别在于它缺少遗忘门，并使用指数线性单元 (ELU) 作为其内部激活函数。由于该单元永远不会遗忘，因此称其为 LLTM 或长长期记忆单元。它同时具有 C++ 和 CUDA 实现，根据放置此模块的目标设备自动切换。

参数:

input_features (int) – 输入特征数据的大小
state_size (int) – 循环单元状态的大小

参考：https://pytorch.ac.cn/tutorials/advanced/cpp_extension.html

forward(input, state)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

ConjugateGradient#

class monai.networks.layers.ConjugateGradient(linear_op, num_iter)[source]#

线性系统 Ax = y 的共轭梯度 (CG) 求解器。

对于正定且自伴随的 linear_op，CG 保证收敛。CG 常用于求解 Ax = y 形式的线性系统，其中 A 太大而无法显式存储，但可以通过线性算子进行计算。

因此，此处我们不会将 A 显式设置为矩阵，而是设置为线性算子。例如，A 可以是 FFT/IFFT 操作

__init__(linear_op, num_iter)[source]#

参数:

linear_op (Callable) – 线性算子
num_iter (int) – 运行 CG 的迭代次数

forward(x, y)[source]#

运行 num_iter 次共轭梯度迭代以求解 Ax = y

参数:

x (Tensor) – 张量（实数或复数）；线性系统 Ax = y 的初始猜测值。
For (x 的大小应该适用于该线性算子。)
示例
FFT (如果线性算子是)
the (那么 x 是 HCHW；如果)
multiplication (线性算子是一个矩阵)
vector (那么 x 是一个向量)
y (Tensor) – 张量（实数或复数）；测量值。与 x 大小相同

返回:

Ax = y 的解

返回类型:

update(x, p, r, rsold)[source]#

执行一次 CG 方法的迭代。它以当前的解 x、当前搜索方向 p、当前残差 r 和旧的残差范数 rsold 作为输入。然后它计算新的解、搜索方向、残差和残差范数，并返回它们。

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

Utilities#

monai.networks.layers.convutils.calculate_out_shape(in_shape, kernel_size, stride, padding)[source]#

当对形状为 inShape 的张量应用核大小为 kernel_size、步长为 stride、输入填充值为 padding 的卷积时，计算输出张量的形状。所有参数都可以是标量或多个值，如果所有输入都是标量，则返回值为标量。

返回类型:: UnionType[tuple[int, …], int]

monai.networks.layers.convutils.gaussian_1d(sigma, truncated=4.0, approx='erf', normalize=False)[source]#

一维高斯核。

参数:

sigma (Tensor) – 核的标准差
truncated (float) – 尾部长度
approx (str) –
离散高斯核类型，可用选项为“erf”、“sampled”和“scalespace”。
- erf 近似法通过误差函数进行插值；
- sampled 使用采样的高斯核；
- scalespace 对应于基于改进贝塞尔函数（modified Bessel functions）的 https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel。
normalize (bool) – 是否使用 kernel.sum() 对核进行归一化。

引发异常:

ValueError – 当 truncated 非正数时。

返回类型:

Tensor

返回:

1D torch 张量

monai.networks.layers.convutils.polyval(coef, x)[source]#

在 x 处评估由 coef 定义的多项式。

对于 1D 系数序列（长度 n），评估

y = coef[n-1] + x * (coef[n-2] + ... + x * (coef[1] + x * coef[0]))

参数:

coef – 表示多项式系数的浮点序列
x – 表示多项式变量的浮点数或浮点数序列

返回类型:

Tensor

返回:

1D torch 张量

monai.networks.layers.convutils.same_padding(kernel_size, dilation=1)[source]#

返回确保使用给定核大小的卷积在步长为 1 时产生与输入形状相同的输出所需的填充值，否则确保形状为输入除以步长并向下取整。

引发异常:: NotImplementedError – 当 np.any((kernel_size - 1) * dilation % 2 == 1) 时。
返回类型:: UnionType[tuple[int, …], int]

monai.networks.layers.utils.get_act_layer(name)[source]#

创建激活层实例。

例如，创建激活层

from monai.networks.layers import get_act_layer

s_layer = get_act_layer(name="swish")
p_layer = get_act_layer(name=("prelu", {"num_parameters": 1, "init": 0.25}))

参数:: name (UnionType[tuple, str]) – 激活类型字符串或类型字符串和参数的元组。

monai.networks.layers.utils.get_dropout_layer(name, dropout_dim=1)[source]#

创建 dropout 层实例。

例如，创建 dropout 层

from monai.networks.layers import get_dropout_layer

d_layer = get_dropout_layer(name="dropout")
a_layer = get_dropout_layer(name=("alphadropout", {"p": 0.25}))

参数:

name (UnionType[tuple, str, float, int]) – dropout 比率或 dropout 类型和参数的元组。
dropout_dim (UnionType[int, None]) – dropout 操作的空间维度。

monai.networks.layers.utils.get_norm_layer(name, spatial_dims=1, channels=1)[source]#

创建归一化层实例。

例如，创建归一化层

from monai.networks.layers import get_norm_layer

g_layer = get_norm_layer(name=("group", {"num_groups": 1}))
n_layer = get_norm_layer(name="instance", spatial_dims=2)

参数:

name (UnionType[tuple, str]) – 归一化类型字符串或类型字符串和参数的元组。
spatial_dims (UnionType[int, None]) – 输入的空间维度数量。
channels (UnionType[int, None]) – 当归一化层需要此参数但未在 norm 参数中指定时的特征/通道数。

monai.networks.layers.utils.get_pool_layer(name, spatial_dims=1)[source]#

创建池化层实例。

例如，创建自适应平均（adaptiveavg）层

from monai.networks.layers import get_pool_layer

pool_layer = get_pool_layer(("adaptiveavg", {"output_size": (1, 1, 1)}), spatial_dims=3)

参数:

name (UnionType[tuple, str]) – 池化类型字符串或类型字符串和参数的元组。
spatial_dims (UnionType[int, None]) – 输入的空间维度数量。

Nets#

AHNet#

class monai.networks.nets.AHNet(layers=(3, 4, 6, 3), spatial_dims=3, in_channels=1, out_channels=1, psp_block_num=4, upsample_mode='transpose', pretrained=False, progress=True)[source]#

基于各向异性混合网络 (Anisotropic Hybrid Network) 的 AHNet。改编自 lsqshr 的官方代码。除了支持 3D 输入的原始网络外，此实现还支持 2D 输入。根据反卷积测试，使用 "transpose" 而不是线性插值更快。因此，此实现将 "transpose" 设置为默认的上采样方法。

为了满足结构要求，每个空间维度的输入大小（最后一个除外）应：在 transpose 模式下可被 2 ** (psp_block_num + 3) 整除且不小于 32，在其他上采样模式下应可被 32 整除且不小于 2 ** (psp_block_num + 3)。此外，最后一个空间维度的输入大小应可被 32 整除，并且至少有一个空间大小应不小于 64。

参数:

layers (tuple) – 网络 4 层的残差块数量 (layer1…layer4)。默认为 (3, 4, 6, 3)。
spatial_dims (int) – 输入数据的空间维度。默认为 3。
in_channels (int) – 网络输入通道数。默认为 1。
out_channels (int) – 网络输出通道数。默认为 1。
psp_block_num (int) – 网络末端输出层之前使用的金字塔体积池化模块数量，用于提取多尺度特征。该数字应为属于 [0,4] 的整数。默认为 4。
upsample_mode (str) –
["transpose", "bilinear", "trilinear", nearest] 上采样操作模式。使用后两种模式无法保证模型的可复现性。默认为 transpose。
- "transpose"，使用转置卷积层。
- "bilinear"，使用双线性插值。
- "trilinear"，使用三线性插值。
- "nearest"，使用最近邻插值。
pretrained (bool) – 是否从 ResNet50 加载预训练权重来初始化卷积层，默认为 False。
progress (bool) – 如果为 True，则在 stderr 中显示预训练权重的下载进度条。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

DenseNet#

class monai.networks.nets.DenseNet(spatial_dims, in_channels, out_channels, init_features=64, growth_rate=32, block_config=(6, 12, 24, 16), bn_size=4, act=('relu', {'inplace': True}), norm='batch', dropout_prob=0.0)[source]#

基于稠密连接卷积网络 (Densely Connected Convolutional Networks) 的 Densenet。改编自 PyTorch Hub 2D 版本：https://pytorch.ac.cn/vision/stable/models.html#id16。当 spatial_dims 为 3 且启用 CUDA 时，该网络是非确定性的。有关更多详细信息，请查看以下链接：https://pytorch.ac.cn/docs/stable/generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出类别数。
init_features (int) – 第一个卷积层中的滤波器数量。
growth_rate (int) – 每层添加多少个滤波器（论文中的 k）。
block_config (Sequence[int]) – 每个池化块中的层数。
bn_size (int) – 瓶颈层数量的乘数因子。（即瓶颈层中的 bn_size * k 个特征）
act (UnionType[str, tuple]) – 激活类型和参数。默认为 relu。
norm (UnionType[str, tuple]) – 特征归一化类型和参数。默认为 batch norm。
dropout_prob (float) – 每个密集层之后的 dropout 率。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

DenseNet121#

class monai.networks.nets.DenseNet121(spatial_dims, in_channels, out_channels, init_features=64, growth_rate=32, block_config=(6, 12, 24, 16), pretrained=False, progress=True, **kwargs)[source]#: 当 spatial_dims 为 2 时，具有可选预训练支持的 DenseNet121。

DenseNet169#

class monai.networks.nets.DenseNet169(spatial_dims, in_channels, out_channels, init_features=64, growth_rate=32, block_config=(6, 12, 32, 32), pretrained=False, progress=True, **kwargs)[source]#: 当 spatial_dims 为 2 时，具有可选预训练支持的 DenseNet169。

DenseNet201#

class monai.networks.nets.DenseNet201(spatial_dims, in_channels, out_channels, init_features=64, growth_rate=32, block_config=(6, 12, 48, 32), pretrained=False, progress=True, **kwargs)[source]#: 当 spatial_dims 为 2 时，具有可选预训练支持的 DenseNet201。

DenseNet264#

class monai.networks.nets.DenseNet264(spatial_dims, in_channels, out_channels, init_features=64, growth_rate=32, block_config=(6, 12, 64, 48), pretrained=False, progress=True, **kwargs)[source]#

EfficientNet#

class monai.networks.nets.EfficientNet(blocks_args_str, spatial_dims=2, in_channels=3, num_classes=1000, width_coefficient=1.0, depth_coefficient=1.0, dropout_rate=0.2, image_size=224, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), drop_connect_rate=0.2, depth_divisor=8)[source]#

__init__(blocks_args_str, spatial_dims=2, in_channels=3, num_classes=1000, width_coefficient=1.0, depth_coefficient=1.0, dropout_rate=0.2, image_size=224, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), drop_connect_rate=0.2, depth_divisor=8)[source]#

基于反思卷积神经网络的模型缩放 (Rethinking Model Scaling for Convolutional Neural Networks) 的 EfficientNet。改编自 EfficientNet-PyTorch。

参数:

blocks_args_str (list[str]) – 块定义。
spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
num_classes (int) – 输出类别数。
width_coefficient (float) – 宽度乘数系数（论文中的 w）。
depth_coefficient (float) – 深度乘数系数（论文中的 d）。
dropout_rate (float) – dropout 层的 dropout 率。
image_size (int) – 输入图像分辨率。
norm (UnionType[str, tuple]) – 特征归一化类型和参数。
drop_connect_rate (float) – drop connection（单个权重）层的 drop 速率。
depth_divisor (int) – 通道舍入的深度除数。

forward(inputs)[source]#

参数:

inputs (Tensor) – 输入在空间上应具有 N 个维度
`` (Batch, in_channels, dim_0[, dim_1, ..., dim_N])

返回:

形状为 (Batch, num_classes) 的分类预测 torch 张量。

set_swish(memory_efficient=True)[source]#

将 swish 函数设置为内存高效（用于训练）或标准（用于 JIT 导出）。

参数:: memory_efficient (bool) – 是否使用 swish 的内存高效版本。
返回类型:: None

BlockArgs#

class monai.networks.nets.BlockArgs(num_repeat: int, kernel_size: int, stride: int, expand_ratio: int, input_filters: int, output_filters: int, id_skip: bool, se_ratio: float | None = None)[source]#

用于辅助解码 MBConvBlock 定义参数字符串表示的 BlockArgs 对象。: 用于 MBConvBlock 定义的参数。

expand_ratio: int#: 字段编号 3 的别名

static from_string(block_string)[source]#

通过参数的字符串表示获取一个 BlockArgs 对象。

参数:: block_string (str) – 参数的字符串表示。示例：“r1_k3_s11_e1_i32_o16_se0.25”。
返回:: 在此函数顶部定义的 namedtuple。
返回类型:: BlockArgs

id_skip: bool#: 字段编号 6 的别名

input_filters: int#: 字段编号 4 的别名

kernel_size: int#: 字段编号 1 的别名

num_repeat: int#: 字段编号 0 的别名

output_filters: int#: 字段编号 5 的别名

se_ratio: float | None#: 字段编号 7 的别名

stride: int#: 字段编号 2 的别名

to_string()[source]#

返回当前 BlockArgs 对象的块字符串表示形式

返回:

BlockArgs 对象参数的字符串表示形式。: 示例：“r1_k3_s11_e1_i32_o16_se0.25_noskip”。

EfficientNetBN#

class monai.networks.nets.EfficientNetBN(model_name, pretrained=True, progress=True, spatial_dims=2, in_channels=3, num_classes=1000, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), adv_prop=False)[source]#

__init__(model_name, pretrained=True, progress=True, spatial_dims=2, in_channels=3, num_classes=1000, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), adv_prop=False)[source]#

EfficientNet 的通用封装，用于初始化 EfficientNet-B0 到 EfficientNet-B7 模型。model_name 是强制参数，因为不存在 EfficientNetBN 本身，它需要 N 在 [0, 1, 2, 3, 4, 5, 6, 7, 8] 中才能成为一个模型。

参数:

model_name (str) – 要初始化的模型名称，可选自 [efficientnet-b0, …, efficientnet-b8, efficientnet-l2]。
pretrained (bool) – 是否初始化预训练的 ImageNet 权重，仅在 spatial_dims=2 且使用批归一化 (batch norm) 时可用。
progress (bool) – 是否显示预训练权重下载进度。
spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
num_classes (int) – 输出类别数。
norm (UnionType[str, tuple]) – 特征归一化类型和参数。
adv_prop (bool) – 是否使用通过对抗样本训练的权重。此参数仅在 pretrained 为 True 时有效。

示例

# for pretrained spatial 2D ImageNet
>>> image_size = get_efficientnet_image_size("efficientnet-b0")
>>> inputs = torch.rand(1, 3, image_size, image_size)
>>> model = EfficientNetBN("efficientnet-b0", pretrained=True)
>>> model.eval()
>>> outputs = model(inputs)

# create spatial 2D
>>> model = EfficientNetBN("efficientnet-b0", spatial_dims=2)

# create spatial 3D
>>> model = EfficientNetBN("efficientnet-b0", spatial_dims=3)

# create EfficientNetB7 for spatial 2D
>>> model = EfficientNetBN("efficientnet-b7", spatial_dims=2)

EfficientNetBNFeatures#

class monai.networks.nets.EfficientNetBNFeatures(model_name, pretrained=True, progress=True, spatial_dims=2, in_channels=3, num_classes=1000, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), adv_prop=False)[source]#

__init__(model_name, pretrained=True, progress=True, spatial_dims=2, in_channels=3, num_classes=1000, norm=('batch', {'eps': 0.001, 'momentum': 0.01}), adv_prop=False)[source]#

初始化 EfficientNet-B0 到 EfficientNet-B7 模型作为主干网络（backbone），该主干网络可用作分割和目标检测模型的编码器。与类 EfficientNetBN 相比，唯一的区别在于 forward 函数。

此类参考了 PyTorch 图像模型。

forward(inputs)[source]#

参数:

inputs (Tensor) – 输入在空间上应具有 N 个维度
`` (Batch, in_channels, dim_0[, dim_1, ..., dim_N])

返回:

一系列 torch 张量 (Tensors)。

SegResNet#

class monai.networks.nets.SegResNet(spatial_dims=3, init_filters=8, in_channels=1, out_channels=2, dropout_prob=None, act=('RELU', {'inplace': True}), norm=('GROUP', {'num_groups': 8}), norm_name='', num_groups=8, use_conv_final=True, blocks_down=(1, 2, 2, 4), blocks_up=(1, 1, 1), upsample_mode=nontrainable)[source]#

基于使用自动编码器正则化的 3D MRI 脑肿瘤分割的 SegResNet。该模块不包含变分自编码器 (VAE)。该模型支持 2D 或 3D 输入。

参数:

spatial_dims (int) – 输入数据的空间维度。默认为 3。
init_filters (int) – 初始卷积层的输出通道数。默认为 8。
in_channels (int) – 网络输入的通道数。默认为 1。
out_channels (int) – 网络输出的通道数。默认为 2。
dropout_prob (Optional[float, None]) – 元素被置零的概率。默认为 None。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 RELU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 GROUP。
norm_name (str) – 特征归一化类型的弃用选项。
num_groups (int) – 组归一化参数的弃用选项。
use_conv_final (bool) – 是否添加最终输出的卷积块。默认为 True。
blocks_down (tuple) – 每一层中下采样块的数量。默认为 [1,2,2,4]。
blocks_up (tuple) – 每一层中上采样块的数量。默认为 [1,1,1]。
upsample_mode (UnionType[UpsampleMode, str]) –
["deconv", "nontrainable", "pixelshuffle"] 上采样操作的模式。使用 nontrainable 模式无法保证模型的可复现性。默认为 nontrainable。
- deconv，使用转置卷积层。
- nontrainable，使用不可训练的线性插值。
- pixelshuffle，使用 monai.networks.blocks.SubpixelUpsample。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

SegResNetDS#

class monai.networks.nets.SegResNetDS(spatial_dims=3, init_filters=32, in_channels=1, out_channels=2, act='relu', norm='batch', blocks_down=(1, 2, 2, 4), blocks_up=None, dsdepth=1, preprocess=None, upsample_mode='deconv', resolution=None)[source]#

基于使用自动编码器正则化的 3D MRI 脑肿瘤分割的 SegResNetDS。它类似于 https://docs.monai.org.cn/en/stable/networks.html#segresnet，并进行了一些改进，包括深度监督 (deep supervision) 和对非各向同性内核的支持。

参数:

spatial_dims (int) – 输入数据的空间维度。默认为 3。
init_filters (int) – 初始卷积层的输出通道数。默认为 32。
in_channels (int) – 网络输入的通道数。默认为 1。
out_channels (int) – 网络输出的通道数。默认为 2。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 RELU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 BATCH。
blocks_down (tuple) – 每一层中下采样块的数量。默认为 [1,2,2,4]。
blocks_up (Optional[tuple, None]) – 上采样块的数量（可选）。
dsdepth (int) – 深度监督的层级数量。这将决定在每个尺度水平上输出列表的长度。当 dsdepth==1 时，仅返回单个输出。
preprocess (Union[Module, Callable, None]) – 在模型前向传播之前应用的可选可调用函数。
resolution (Optional[tuple, None]) –
可选的输入图像分辨率。提供此参数时，网络将首先使用非各向同性卷积核，将图像间距调整为近似各向同性空间。否则，默认情况下，卷积核大小和下采样始终是各向同性的。

空间形状约束：如果 resolution 为 None（各向同性模式），则每个空间维度必须能被 2 ** (len(blocks_down) - 1) 整除。使用默认的 blocks_down=(1, 2, 2, 4)，每个维度必须能被 8 整除。如果提供了 resolution（非各向同性模式），整除性可能因维度而异；请使用 shape_factor() 获取确切的必需因子，并使用 is_valid_shape() 验证形状。

示例
```
model = SegResNetDS(spatial_dims=3, blocks_down=(1, 2, 2, 4))
print(model.shape_factor())  # [8, 8, 8]
print(model.is_valid_shape((1, 1, 128, 128, 128)))  # True
print(model.is_valid_shape((1, 1, 100, 100, 100)))  # False
```

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: UnionType[None, Tensor, list[Tensor]]

is_valid_shape(x)[source]#: 计算输入形状是否能被当前网络配置的最小因子整除

shape_factor()[source]#: 计算输入图像形状必须能被整除的因子（除数）

SegResNetDS2#

class monai.networks.nets.SegResNetDS2(spatial_dims=3, init_filters=32, in_channels=1, out_channels=2, act='relu', norm='batch', blocks_down=(1, 2, 2, 4), blocks_up=None, dsdepth=1, preprocess=None, upsample_mode='deconv', resolution=None)[source]#

SegResNetDS2 为 SegResNetDS 增加了一个额外的解码器分支，并且是 VISTA3D 的图像编码器: <https://arxiv.org/abs/2406.05285>`_。

参数:

spatial_dims (int) – 输入数据的空间维度。默认为 3。
init_filters (int) – 初始卷积层的输出通道数。默认为 32。
in_channels (int) – 网络输入的通道数。默认为 1。
out_channels (int) – 网络输出的通道数。默认为 2。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 RELU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 BATCH。
blocks_down (tuple) – 每一层中下采样块的数量。默认为 [1,2,2,4]。
blocks_up (Optional[tuple, None]) – 上采样块的数量（可选）。
dsdepth (int) – 深度监督的层级数量。这将决定在每个尺度水平上输出列表的长度。当 dsdepth==1 时，仅返回单个输出。
preprocess (Union[Module, Callable, None]) – 在模型前向传播之前应用的可选可调用函数。
resolution (Optional[tuple, None]) – 可选的输入图像分辨率。提供此参数时，网络将首先使用非各向同性卷积核，将图像间距调整为近似各向同性空间。否则，默认情况下，卷积核大小和下采样始终是各向同性的。

forward(x, with_point=True, with_label=True)[source]#

参数:

x (Tensor) – 输入张量。
with_point (bool) – 如果为 true，则返回点分支输出。
with_label (bool) – 如果为 true，则返回标签分支输出。

返回类型:

tuple[UnionType[None, Tensor, list[Tensor]], UnionType[None, Tensor, list[Tensor]]]

set_auto_grad(auto_freeze=False, point_freeze=False)[source]#

参数:

auto_freeze – 如果为 true，则冻结图像编码器和自动分支。
point_freeze – 如果为 true，则冻结图像编码器和点分支。

SegResNetVAE#

class monai.networks.nets.SegResNetVAE(input_image_size, vae_estimate_std=False, vae_default_std=0.3, vae_nz=256, spatial_dims=3, init_filters=8, in_channels=1, out_channels=2, dropout_prob=None, act=('RELU', {'inplace': True}), norm=('GROUP', {'num_groups': 8}), use_conv_final=True, blocks_down=(1, 2, 2, 4), blocks_up=(1, 1, 1), upsample_mode=nontrainable)[source]#

基于使用自动编码器正则化的 3D MRI 脑肿瘤分割的 SegResNetVAE。该模块包含变分自编码器 (VAE)。该模型支持 2D 或 3D 输入。

参数:

input_image_size (Sequence[int]) – 输入到网络中的图像尺寸。它用于确定 VAE 中全连接 (fc) 层的输入特征数。
vae_estimate_std (bool) – 是否在 VAE 中估计标准差。默认为 False。
vae_default_std (float) – 如果不估计标准差，则使用默认值。默认为 0.3。
vae_nz (int) – VAE 中潜在变量的数量。默认为 256。其中，128 表示均值，128 表示标准差。
spatial_dims (int) – 输入数据的空间维度。默认为 3。
init_filters (int) – 初始卷积层的输出通道数。默认为 8。
in_channels (int) – 网络输入的通道数。默认为 1。
out_channels (int) – 网络输出的通道数。默认为 2。
dropout_prob (Optional[float, None]) – 元素被置零的概率。默认为 None。
act (UnionType[str, tuple]) – 激活类型及参数。默认为 RELU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 GROUP。
use_conv_final (bool) – 是否添加最终输出的卷积块。默认为 True。
blocks_down (tuple) – 每一层中下采样块的数量。默认为 [1,2,2,4]。
blocks_up (tuple) – 每一层中上采样块的数量。默认为 [1,1,1]。
upsample_mode (UnionType[UpsampleMode, str]) –
["deconv", "nontrainable", "pixelshuffle"] 上采样操作的模式。使用 nontrainable 模式无法保证模型的可复现性。默认为 nontrainable。
- deconv，使用转置卷积层。
- nontrainable，使用不可训练的线性插值。
- pixelshuffle，使用 monai.networks.blocks.SubpixelUpsample。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

ResNet#

class monai.networks.nets.ResNet(block, layers, block_inplanes, spatial_dims=3, n_input_channels=3, conv1_t_size=7, conv1_t_stride=1, no_max_pool=False, shortcut_type='B', widen_factor=1.0, num_classes=400, feed_forward=True, bias_downsample=True, act=('relu', {'inplace': True}), norm='batch')[source]#

ResNet 基于：图像识别的深度残差学习和时空 3D CNN 能否追溯 2D CNN 和 ImageNet 的历史？。改编自 kenshohara/3D-ResNets-PyTorch。

参数:

block (UnionType[type[UnionType[ResNetBlock, ResNetBottleneck]], str]) – 要使用的 ResNet 块，可以是 Basic 或 Bottleneck。ResNet 块类或字符串。Basic：ResNetBlock 或 ‘basic’；Bottleneck：ResNetBottleneck 或 ‘bottleneck’
layers (list[int]) – 使用的层数。
block_inplanes (list[int]) – 确定每一步平面的大小。也可以通过 widen_factor 进行调整。
spatial_dims (int) – 输入图像的空间维度数量。
n_input_channels (int) – 第一卷积层的输入通道数。
conv1_t_size (UnionType[tuple[int], int]) – 第一卷积层的大小，决定内核和填充。
conv1_t_stride (UnionType[tuple[int], int]) – 第一卷积层的步长。
no_max_pool (bool) – 确定是否使用 maxpool 层的布尔参数。
shortcut_type (str) – 要使用的下采样块。选项为 ‘A’, ‘B’，默认为 ‘B’。- ‘A’：使用 self._downsample_basic_block。- ‘B’：内核大小为 1 的卷积 + 归一化。
widen_factor (float) – 每一层的输出扩充因子。
num_classes (int) – 输出数量（分类数）。
feed_forward (bool) – 是否为输出添加 FC 层，默认为 True。
bias_downsample (bool) – 当 shortcut_type 为 ‘B’ 时，是否在下采样块中使用偏置项，默认为 True。
act (UnionType[str, tuple]) – 激活类型和参数。默认为 relu。
norm (UnionType[str, tuple]) – 特征归一化类型和参数。默认为 batch norm。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

ResNetFeatures#

class monai.networks.nets.ResNetFeatures(model_name, pretrained=True, spatial_dims=3, in_channels=1)[source]#

__init__(model_name, pretrained=True, spatial_dims=3, in_channels=1)[source]#

初始化 resnet18 到 resnet200 模型作为主干网络，该主干网络可用作分割和目标检测模型的编码器。

与类 ResNet 相比，唯一的区别在于 forward 函数。

参数:

model_name (str) – 要初始化的模型名称，可选自 [resnet10, …, resnet200]。
pretrained (bool) – 是否初始化预训练的 MedicalNet 权重，仅在 spatial_dims=3 且 in_channels=1 时可用。
spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 第一卷积层的输入通道数。

forward(inputs)[source]#

参数:

inputs (Tensor) – 输入在空间上应具有 N 个维度
`` (Batch, in_channels, dim_0[, dim_1, ..., dim_N])

返回:

一系列 torch 张量 (Tensors)。

SENet#

class monai.networks.nets.SENet(spatial_dims, in_channels, block, layers, groups, reduction, dropout_prob=0.2, dropout_dim=1, inplanes=128, downsample_kernel_size=3, input_3x3=True, num_classes=1000)[source]#

基于 Squeeze-and-Excitation 网络的 SENet。改编自 Cadene Hub 2D 版本。

参数:

spatial_dims (int) – 输入数据的空间维度。
in_channels (int) – 输入数据的通道数。
block (UnionType[type[UnionType[SEBottleneck, SEResNetBottleneck, SEResNeXtBottleneck]], str]) – SEBlock 类或字符串。SENet154：SEBottleneck 或 ‘se_bottleneck’；SE-ResNet 模型：SEResNetBottleneck 或 ‘se_resnet_bottleneck’；SE-ResNeXt 模型：SEResNeXtBottleneck 或 ‘se_resnetxt_bottleneck’
layers (Sequence[int]) – 网络 4 个层（layer1…layer4）的残差块数量。
groups (int) – 每个瓶颈块中 3x3 卷积的组数。SENet154：64；SE-ResNet 模型：1；SE-ResNeXt 模型：32
reduction (int) – Squeeze-and-Excitation 模块的缩减比例。所有模型：16
dropout_prob (UnionType[float, None]) – Dropout 层的丢弃概率。如果为 None，则不使用 Dropout 层。SENet154：0.2；SE-ResNet 模型：None；SE-ResNeXt 模型：None
dropout_dim (int) – 确定 dropout 的维度。默认为 1。当 dropout_dim = 1 时，随机将每个通道的部分元素置零。当 dropout_dim = 2 时，随机置零整个通道（通道是 2D 特征图）。当 dropout_dim = 3 时，随机置零整个通道（通道是 3D 特征图）。
inplanes (int) – layer1 的输入通道数。SENet154：128；SE-ResNet 模型：64；SE-ResNeXt 模型：64
downsample_kernel_size (int) – layer2、layer3 和 layer4 中下采样卷积的内核大小。SENet154：3；SE-ResNet 模型：1；SE-ResNeXt 模型：1
input_3x3 (bool) – 如果为 True，则在 layer0 中使用三个 3x3 卷积，而不是单个 7x7 卷积。- SENet154：True - SE-ResNet 模型：False - SE-ResNeXt 模型：False
num_classes (int) – last_linear 层中的输出数量。所有模型：1000

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

SENet154#

class monai.networks.nets.SENet154(layers=(3, 8, 36, 3), groups=64, reduction=16, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SENet154，当 spatial_dims 为 2 时支持可选的预训练权重。

SEResNet50#

class monai.networks.nets.SEResNet50(layers=(3, 4, 6, 3), groups=1, reduction=16, dropout_prob=None, inplanes=64, downsample_kernel_size=1, input_3x3=False, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SEResNet50，当 spatial_dims 为 2 时支持可选的预训练权重。

SEResNet101#

class monai.networks.nets.SEResNet101(layers=(3, 4, 23, 3), groups=1, reduction=16, inplanes=64, downsample_kernel_size=1, input_3x3=False, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SEResNet101，当 spatial_dims 为 2 时支持可选的预训练权重。

SEResNet152#

class monai.networks.nets.SEResNet152(layers=(3, 8, 36, 3), groups=1, reduction=16, inplanes=64, downsample_kernel_size=1, input_3x3=False, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SEResNet152，当 spatial_dims 为 2 时支持可选的预训练权重。

SEResNext50#

class monai.networks.nets.SEResNext50(layers=(3, 4, 6, 3), groups=32, reduction=16, dropout_prob=None, inplanes=64, downsample_kernel_size=1, input_3x3=False, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SEResNext50，当 spatial_dims 为 2 时支持可选的预训练权重。

SEResNext101#

class monai.networks.nets.SEResNext101(layers=(3, 4, 23, 3), groups=32, reduction=16, dropout_prob=None, inplanes=64, downsample_kernel_size=1, input_3x3=False, pretrained=False, progress=True, **kwargs)[source]#: 基于 Squeeze-and-Excitation 网络的 SEResNext101，当 spatial_dims 为 2 时支持可选的预训练权重。

HighResNet#

class monai.networks.nets.HighResNet(spatial_dims=3, in_channels=1, out_channels=1, norm_type=('batch', {'affine': True}), acti_type=('relu', {'inplace': True}), dropout_prob=0.0, bias=False, layer_params=({'kernel_size': 3, 'n_features': 16, 'name': 'conv_0'}, {'kernels': (3, 3), 'n_features': 16, 'name': 'res_1', 'repeat': 3}, {'kernels': (3, 3), 'n_features': 32, 'name': 'res_2', 'repeat': 3}, {'kernels': (3, 3), 'n_features': 64, 'name': 'res_3', 'repeat': 3}, {'kernel_size': 1, 'n_features': 80, 'name': 'conv_1'}, {'kernel_size': 1, 'name': 'conv_2'}), channel_matching=pad)[source]#

基于 Li 等人，“论 3D 卷积网络的紧凑性、效率和表示：作为借口任务的大脑分割”，IPMI ‘17 的 highres3dnet 的重新实现。

改编自：NifTK/NiftyNet fepegar/highresnet

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
norm_type (UnionType[str, tuple]) – 特征归一化类型及参数。默认为 ("batch", {"affine": True})。
acti_type (UnionType[str, tuple]) – 激活类型及参数。默认为 ("relu", {"inplace": True})。
dropout_prob (UnionType[tuple, str, float, None]) – 特征图被置零的概率（仅适用于倒数第二层卷积层）。
bias (bool) –
卷积块中是否包含偏置项。默认为 False。根据性能调优指南，如果卷积层后面直接跟着批归一化层，则不应包含偏置。
layer_params (Sequence[dict]) – 指定每一层/块的关键参数。
channel_matching (UnionType[ChannelMatching, str]) –
{"pad", "project"} 指定处理残差分支和卷积分支通道不匹配的情况。默认为 "pad"。
- "pad": 使用零填充。
- "project": 使用内核大小为 1 的可训练卷积。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

class monai.networks.nets.HighResBlock(spatial_dims, in_channels, out_channels, kernels=(3, 3), dilation=1, norm_type=('batch', {'affine': True}), acti_type=('relu', {'inplace': True}), bias=False, channel_matching=pad)[source]#

__init__(spatial_dims, in_channels, out_channels, kernels=(3, 3), dilation=1, norm_type=('batch', {'affine': True}), acti_type=('relu', {'inplace': True}), bias=False, channel_matching=pad)[源码]#

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernels (Sequence[int]) – kernels 中的每个整数 k 对应一个卷积核大小为 k 的卷积层。
dilation (UnionType[Sequence[int], int]) – 卷积核元素之间的间距。
norm_type (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 ("batch", {"affine": True})。
acti_type (UnionType[tuple, str]) – {"relu", "prelu", "relu6"} 使用 ReLU 或 PReLU 的非线性激活。默认为 "relu"。
bias (bool) –
卷积块中是否包含偏置项。默认为 False。根据性能调优指南，如果卷积层后面直接跟着批归一化层，则不应包含偏置。
channel_matching (UnionType[ChannelMatching, str]) –
{"pad", "project"} 指定处理残差分支和卷积分支通道不匹配的情况。默认为 "pad"。
- "pad": 使用零填充。
- "project": 使用内核大小为 1 的可训练卷积。

引发异常:

ValueError – 当 channel_matching=pad 且 in_channels > out_channels 时抛出。数值不兼容。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

DynUNet#

class monai.networks.nets.DynUNet(spatial_dims, in_channels, out_channels, kernel_size, strides, upsample_kernel_size, filters=None, dropout=None, norm_name=('INSTANCE', {'affine': True}), act_name=('leakyrelu', {'inplace': True, 'negative_slope': 0.01}), deep_supervision=False, deep_supr_num=1, res_block=False, trans_bias=False)[源码]#

此动态 UNet (DynUNet) 的重现基于：生物医学图像分割深度学习方法的自动化设计。nnU-Net：一种用于 U-Net 医学图像分割的自适应框架。用于脑肿瘤分割的优化 U-Net。

该模型相比 monai.networks.nets.UNet 在三个方面更加灵活：

卷积块支持残差连接。

每一层可以使用各向异性的卷积核大小和步长。

可以添加深度监督头。

该模型支持 2D 或 3D 输入，由四种块组成：一个输入块、n 个下采样块、一个瓶颈层和 n+1 个上采样块（其中 n>0）。输入序列的第一个和最后一个卷积核与步长值分别用于输入块和瓶颈层，其余的值用于下采样和上采样块。因此，请确保输入序列（kernel_size 和 strides）的长度不小于 3，以保证至少有一个下采样和一个上采样块。

为满足结构要求，每个空间维度的输入大小应能被该维度所有步长的乘积整除。此外，最小空间大小的维度中至少应有一个维度的长度是所有步长乘积的两倍。例如，如果 strides=((1, 2, 4), 2, 2, 1)，则空间大小应能被 (4, 8, 16) 整除，且最小空间大小为 (8, 8, 16)、(4, 16, 16) 或 (4, 8, 32)。

每个空间维度的输出大小等于对应维度的输入大小除以 strides[0] 中的步长。例如，如果 strides=((1, 2, 4), 2, 2, 1) 且输入大小为 (64, 32, 32)，则输出大小为 (64, 16, 8)。

为了向后兼容旧权重，请在调用 load_state_dict 时设置 strict=False。

使用 Medical Segmentation Decathlon 数据集的用例见：Project-MONAI/tutorials。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (Sequence[UnionType[Sequence[int], int]]) – 卷积核大小。
strides (Sequence[UnionType[Sequence[int], int]]) – 每个块的卷积步长。
upsample_kernel_size (Sequence[UnionType[Sequence[int], int]]) – 转置卷积层的卷积核大小。其值应等于 strides[1:]。
filters (Optional[Sequence[int], None]) – 每个块的输出通道数。与 nnU-Net 不同，此实现增加了该参数以增强网络灵活性。如第三篇参考文献所示，确定该参数的一种方式是：[64, 96, 128, 192, 256, 384, 512, 768, 1024][: len(strides)]。上述方式用于 BraTS21 挑战赛任务 1 的获胜网络。若未指定，将采用 nnUNet 的方式。默认为 None。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 INSTANCE。INSTANCE_NVFUSER 是实例归一化层的一种加速版本，可在以下条件满足时使用：1) spatial_dims=3，2) 有可用的 CUDA 设备，3) 已安装 apex，且 4) 使用非 Windows 操作系统。
act_name (UnionType[tuple, str]) – 激活层类型及参数。默认为 leakyrelu。
deep_supervision (bool) – 是否在输出前添加深度监督头。默认为 False。如果为 True，在训练模式下，forward 函数不仅会输出最终特征图（来自 output_block），还会输出来自中间上采样层的特征图。为了统一返回类型（TorchScript 的限制），所有中间特征图都被插值到与最终特征图相同的大小，并堆叠在一起（在第一轴上增加一个新维度）成为一个单一的张量。例如，如果有两个中间特征图形状分别为 (1, 2, 16, 12) 和 (1, 2, 8, 6)，而最终特征图形状为 (1, 2, 32, 24)，则所有中间特征图都将插值到 (1, 2, 32, 24)，且堆叠后的张量形状为 (1, 3, 2, 32, 24)。计算损失时，可以使用 torch.unbind 获取所有特征图，并逐个计算其与真值的损失，然后对所有损失进行加权平均以得到最终损失。
deep_supr_num (int) – 深度监督头输出的特征图数量。该值应大于 0 且小于上采样层的数量。默认为 1。
res_block (bool) – 网络中是否使用基于残差连接的卷积块。默认为 False。
trans_bias (bool) – 是否设置转置卷积层中的偏置参数。默认为 False。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

monai.networks.nets.DynUnet[源码]#: 与 DynUNet 同名

monai.networks.nets.Dynunet[源码]#: 与 DynUNet 同名

UNet#

class monai.networks.nets.UNet(spatial_dims, in_channels, out_channels, channels, strides, kernel_size=3, up_kernel_size=3, num_res_units=0, act='PRELU', norm='INSTANCE', dropout=0.0, bias=True, adn_ordering='NDA')[源码]#

UNet 的增强版，使用 ResidualUnit 类实现了残差单元。残差部分在必要时使用卷积来改变输入维度以匹配输出维度，否则使用 nn.Identity。参考：https://link.springer.com/chapter/10.1007/978-3-030-12029-0_40。

网络的每一层都有编码和解码路径，路径之间有跳跃连接。编码路径中的数据使用步长卷积进行下采样（如果 strides 给定的值大于 1），解码路径中使用步长转置卷积进行上采样。这些下采样或上采样操作发生在每个块的开始，而不是像传统 UNet 实现那样在块之后。

为了进一步解释这一点，请考虑下面给出的第一个示例网络。该网络有 3 层，中间层的步长为 2（最后一层是底部连接，不进行下/上采样）。输入到该网络的数据在编码部分第一层的残差单元的第一次卷积中，空间维度会立即缩小 2 倍。解码部分的最后一层将在第一次卷积中对其输入（来自上一层的数据与来自跳跃连接的数据拼接）进行上采样。这确保了网络的最终输出具有与输入相同的形状。

卷积的填充值经过选择，以确保如果某层的 strides 值是输入大小的因子，则输出大小是输入大小的偶数除数/倍数。一个典型的例子是使用 2 的 strides 值以及 2 的幂倍数的输入。因此，只要维度能被 2 整除，输入就可以被均匀地多次下采样；因此对于示例网络，输入维度必须是 4 的倍数。在下面给出的第二个示例网络中，对于形状为 (1, 1, 240, 240) 的输入，底部层的输入将具有形状 (1, 64, 15, 15)，这证明了输入在空间上被缩小了 2**4 倍。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
channels (Sequence[int]) – 通道序列。顶部块在前。channels 的长度应不少于 2。
strides (Sequence[int]) – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
up_kernel_size (UnionType[Sequence[int], int]) – 上采样卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
num_res_units (int) – 残差单元的数量。默认为 0。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为实例归一化。
dropout (float) – dropout 比率。默认为无 dropout。
bias (bool) –
卷积块中是否有偏置项。默认为 True。根据性能调优指南，如果卷积层后直接跟随批归一化层，偏置应为 False。
adn_ordering (str) – 表示激活 (A)、归一化 (N) 和 dropout (D) 顺序的字符串。默认为 “NDA”。另请参阅：monai.networks.blocks.ADN。

示例

from monai.networks.nets import UNet

# 3 layer network with down/upsampling by a factor of 2 at each layer with 2-convolution residual units
net = UNet(
    spatial_dims=2,
    in_channels=1,
    out_channels=1,
    channels=(4, 8, 16),
    strides=(2, 2),
    num_res_units=2
)

# 5 layer network with simple convolution/normalization/dropout/activation blocks defining the layers
net=UNet(
    spatial_dims=2,
    in_channels=1,
    out_channels=1,
    channels=(4, 8, 16, 32, 64),
    strides=(2, 2, 2, 2),
)

注意：输入数据可接受的空间大小取决于网络的参数。: 要设置合适的空间大小，请查阅教程了解更多细节：Project-MONAI/tutorials。通常，当在下/上采样中使用 2 的步长时，输出维度是下采样时输入的一半，或上采样时的两倍。在这种情况下，如果有 N 层网络，输入的空间维度必须都是 2^N 的倍数。通常，应用 resize、pad 或 crop 变换可以帮助调整输入数据的空间大小。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

monai.networks.nets.Unet[源码]#: 与 UNet 同名

monai.networks.nets.unet[源码]#: 别名：<module ‘monai.networks.nets.unet’ from ‘/home/docs/checkouts/readthedocs.org/user_builds/monai/checkouts/stable/monai/networks/nets/unet.py’>

AttentionUnet#

class monai.networks.nets.AttentionUnet(spatial_dims, in_channels, out_channels, channels, strides, kernel_size=3, up_kernel_size=3, dropout=0.0)[源码]#

Attention Unet 基于 Otkay 等人的研究 “Attention U-Net: Learning Where to Look for the Pancreas” https://arxiv.org/abs/1804.03999

参数:

spatial_dims (int) – 输入图像的空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出类别数。
channels (Sequence[int]) – 通道序列。顶部块在前。channels 的长度应不少于 2。
strides (Sequence[int]) – 卷积所用的步长。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小。
up_kernel_size (UnionType[Sequence[int], int]) – 转置卷积层的卷积核大小。
dropout (float) – dropout 比率。默认为无 dropout。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

UNETR#

class monai.networks.nets.UNETR(in_channels, out_channels, img_size, feature_size=16, hidden_size=768, mlp_dim=3072, num_heads=12, proj_type='conv', norm_name='instance', conv_block=True, res_block=True, dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[源码]#

UNETR 基于：“Hatamizadeh 等人，UNETR: Transformers for 3D Medical Image Segmentation <https://arxiv.org/abs/2103.10504>”

__init__(in_channels, out_channels, img_size, feature_size=16, hidden_size=768, mlp_dim=3072, num_heads=12, proj_type='conv', norm_name='instance', conv_block=True, res_block=True, dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[源码]#

参数:

in_channels (int) – 输入通道的维度。
out_channels (int) – 输出通道的维度。
img_size (UnionType[Sequence[int], int]) – 输入图像的维度。
feature_size (int) – 网络特征大小的维度。默认为 16。
hidden_size (int) – 隐藏层的维度。默认为 768。
mlp_dim (int) – 前馈层的维度。默认为 3072。
num_heads (int) – 注意力头的数量。默认为 12。
proj_type (str) – Patch Embedding 层的类型。默认为 “conv”。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。默认为 “instance”。
conv_block (bool) – 是否使用卷积块。默认为 True。
res_block (bool) – 是否使用残差块。默认为 True。
dropout_rate (float) – 输入单元的丢弃比例。默认为 0.0。
spatial_dims (int) – 空间维度的数量。默认为 3。
qkv_bias (bool) – 是否在自注意力块的 qkv 线性层中应用偏置项。默认为 False。
save_attn (bool) – 是否使自注意力块中的注意力可访问。默认为 False。

示例

# for single channel input 4-channel output with image size of (96,96,96), feature size of 32 and batch norm
>>> net = UNETR(in_channels=1, out_channels=4, img_size=(96,96,96), feature_size=32, norm_name='batch')

 # for single channel input 4-channel output with image size of (96,96), feature size of 32 and batch norm
>>> net = UNETR(in_channels=1, out_channels=4, img_size=96, feature_size=32, norm_name='batch', spatial_dims=2)

# for 4-channel input 3-channel output with image size of (128,128,128), conv position embedding and instance norm
>>> net = UNETR(in_channels=4, out_channels=3, img_size=(128,128,128), proj_type='conv', norm_name='instance')

forward(x_in)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

VISTA3D#

class monai.networks.nets.VISTA3D(image_encoder, class_head, point_head)[源码]#

VISTA3D 基于: VISTA3D: 用于 3D 计算机断层扫描的多功能图像分割和标注模型.

参数:

image_encoder (Module) – 用于特征提取的图像编码器主干。
class_head (Module) – 用于基于类索引的分割的类头。
point_head (Module) – 用于交互式分割的点头。

connected_components_combine(logits, point_logits, point_coords, point_labels, mapping_index, thred=0.5)[源码]#

将自动分割结果与点点击响应相结合。自动结果的形状为 [B, 1, H, W, D]，即来自单个图像块的 B 个前景掩码。在这些 B 个前景掩码中，用户可能通过在 B1 个前景掩码子集上添加点来进行编辑。mapping_index 表示 B 和 B1 之间的对应关系。对于带有点击点的 mapping_index，logits 中的 NaN 值将被 point_logits 替换。同时，点击点添加/移除的区域必须通过 lcc 函数更新。注意，如果一个正向点位于 logits/prev_mask 内部，则包含该正向点的组件将被添加。

参数:

logits (Tensor) – 自动分支结果，[B, 1, H, W, D]。
point_logits (Tensor) – 点分支结果，[B1, 1, H, W, D]。
point_coords (Tensor) – 点坐标，[B1, N, 3]。
point_labels (Tensor) – 点标签，[B1, N]。
mapping_index (Tensor) – [B]。
thred (float) – 将 logits 转换为二值掩码的阈值。

convert_point_label(point_label, label_set=None, special_index=(23, 24, 25, 26, 27, 57, 128))[源码]#

根据类提示转换点标签。对于 special_index 中定义的特殊类，正向/反向点标签将从 1/0 转换为 3/2。目的是将这些类与模糊的类区分开来。

参数:

point_label (Tensor) – 点标签张量，[B, N]。
label_set (Optional[Sequence[int], None]) – 与标签索引匹配的标签索引集。如果标签使用 RelabelID 映射到全局索引，则此 label_set 应为全局映射索引。如果标签未映射到全局索引（例如在零样本评估中），则此 label_set 应为原始索引。
special_index (Sequence[int]) – 需要转换的特殊类索引。

forward(input_images, patch_coords=None, point_coords=None, point_labels=None, class_vector=None, prompt_class=None, labels=None, label_set=None, prev_mask=None, radius=None, val_point_sampler=None, transpose=False, **kwargs)[源码]#

VISTA3D 的前向传播函数。在训练和推理过程中，我们仅支持单个数据块。唯一例外是允许在仅自动分割的情况下，滑动窗口批量大小 > 1。B 表示对象数量，N 表示每个对象的点数量。

参数:

input_images (Tensor) – [1, 1, H, W, D]
point_coords (Optional[Tensor, None]) – [B, N, 3]
point_labels (Optional[Tensor, None]) – [B, N]，-1 表示填充。0/1 表示常规类的反向/正向点。2/3 表示肿瘤等特殊支持类的反向/正向点。
class_vector (Optional[Tensor, None]) – [B, 1]，全局类索引。
prompt_class (Optional[Tensor, None]) – [B, 1]，全局类索引。此值与 point_coords 相关联，以识别这些点是用于零样本还是已支持的类。当同时提供 class_vector 和 point_coords 时，prompt_class 与 class_vector 相同。对于 prompt_class[b] > 512，point_coords[b] 将被视为新颖类。
patch_coords (Optional[list[Sequence[slice]], None]) – Python 切片对象序列列表，表示滑动窗口推理期间的数据块坐标。此值由 sliding_window_inferer 传递。这是训练阶段或验证阶段的指示器。注意，对于滑动窗口批量大小 > 1（仅支持自动分割），patch_coords 将包含多个数据块的坐标。如果包含点提示，批量大小只能为 1，所有使用 patch_coords 的函数将默认使用 patch_coords[0]。
labels (Optional[Tensor, None]) – [1, 1, H, W, D]，真值标签张量，仅用于仅点评估。
label_set (Optional[Sequence[int], None]) – 与标签索引匹配的标签索引集。如果标签使用 RelabelID 映射到全局索引，则此 label_set 应为全局映射索引。如果标签未映射到全局索引（例如在零样本评估中），则此 label_set 应为原始索引。
prev_mask (Optional[Tensor, None]) – [B, N, H_fullsize, W_fullsize, D_fullsize]。这是在任何后处理之前来自 sliding_window_inferer 的转置原始输出。当用户点击点以执行自动结果校正时，这可以是自动结果。
radius (Optional[int, None]) – 单个浮点值，用于控制组合点结果和自动结果时的高斯模糊。高斯组合不用于 VISTA3D 训练，但对微调可能有用。
val_point_sampler (Optional[Callable, None]) – 用于从标签中采样点的函数。仅用于仅点评估。
transpose (bool) – 布尔值。如果为真，输出将转置为 [1, B, H, W, D]。如果从滑动窗口推理器/点推理器调用，则必须为真。

gaussian_combine(logits, point_logits, point_coords, point_labels, mapping_index, radius=None)[源码]#

使用高斯函数将点结果与自动结果相结合。

参数:

logits (Tensor) – 自动分支结果，[B, 1, H, W, D]。
point_logits (Tensor) – 点分支结果，[B1, 1, H, W, D]。
point_coords (Tensor) – 点坐标，[B1, N, 3]。
point_labels (Tensor) – 点标签，[B1, N]。
mapping_index (Tensor) – [B]。
radius (Optional[int, None]) – 高斯球半径。

get_foreground_class_count(class_vector, point_coords)[源码]#

根据类和点提示获取前景类数量。

返回类型:: int

sample_points_patch_val(labels, patch_coords, label_set, use_center=True, mapped_label_set=None, max_ppoint=1, max_npoint=0)[源码]#

在滑动窗口验证期间为数据块采样点。仅用于仅点验证。

参数:

labels (Tensor) – 形状 [1, 1, H, W, D]。
patch_coords (Sequence[slice]) – 滑动窗口切片对象序列。
label_set (Sequence[int]) – 局部索引，必须与标签中的值匹配。
use_center (bool) – 从中心采样点。
mapped_label_set (Optional[Sequence[int], None]) – 全局索引，用于识别特殊类，也是采样点的全局索引。
max_ppoint/max_npoint – 采样正向点和反向点的最大数量。

set_auto_grad(auto_freeze=False, point_freeze=False)[源码]#

冻结自动分支或点分支。

参数:

auto_freeze (bool) – 是否冻结自动分支。
point_freeze (bool) – 是否冻结点分支。

update_point_to_patch(patch_coords, point_coords, point_labels)[源码]#

根据数据块坐标更新 point_coords。如果点位于数据块之外，则删除该坐标并将标签设置为 -1。

参数:

patch_coords (Sequence[slice]) – Python 切片对象序列，表示滑动窗口推理期间的数据块坐标。
point_coords (Tensor) – 点坐标，[B, N, 3]。
point_labels (Tensor) – 点标签，[B, N]。

update_slidingwindow_padding(pad_size, labels, prev_mask, point_coords)[源码]#

图像已被滑动窗口推理器填充。相关的填充需要在滑动窗口推理器外部执行。

参数:

pad_size (UnionType[list, None]) – 从滑动窗口推理器传递的填充大小。
labels (UnionType[Tensor, None]) – 图像标签真值。
prev_mask (UnionType[Tensor, None]) – 之前的分割掩码。
point_coords (UnionType[Tensor, None]) – 点击点坐标。

SwinUNETR#

class monai.networks.nets.SwinUNETR(in_channels, out_channels, patch_size=2, depths=(2, 2, 2, 2), num_heads=(3, 6, 12, 24), window_size=7, qkv_bias=True, mlp_ratio=4.0, feature_size=24, norm_name='instance', drop_rate=0.0, attn_drop_rate=0.0, dropout_path_rate=0.0, normalize=True, norm_layer=<class 'torch.nn.modules.normalization.LayerNorm'>, patch_norm=False, use_checkpoint=False, spatial_dims=3, downsample='merging', use_v2=False)[源码]#

Swin UNETR 基于：“Hatamizadeh 等人，Swin UNETR: Swin Transformers for Semantic Segmentation of Brain Tumors in MRI Images <https://arxiv.org/abs/2201.01266>”

空间形状约束

输入的每个空间维度必须能被 patch_size ** 5 整除。对于默认的 patch_size=2，这意味着每个空间维度必须能被 32（即 2^5 = 32）整除。这一要求来自 Patch Embedding 步骤以及随后 4 个阶段的 PatchMerging 下采样（每个阶段将空间分辨率减半）。

对于自定义的 patch_size，可整除性要求为 patch_size ** 5。

有效的 3D 输入大小示例（使用默认 patch_size=2）：(32, 32, 32)、(64, 64, 64)、(96, 96, 96)、(128, 128, 128)、(64, 32, 192)。

如果输入的空间形状违反此约束，forward() 将引发 ValueError。

__init__(in_channels, out_channels, patch_size=2, depths=(2, 2, 2, 2), num_heads=(3, 6, 12, 24), window_size=7, qkv_bias=True, mlp_ratio=4.0, feature_size=24, norm_name='instance', drop_rate=0.0, attn_drop_rate=0.0, dropout_path_rate=0.0, normalize=True, norm_layer=<class 'torch.nn.modules.normalization.LayerNorm'>, patch_norm=False, use_checkpoint=False, spatial_dims=3, downsample='merging', use_v2=False)[源码]#

参数:

in_channels (int) – 输入通道的维度。
out_channels (int) – 输出通道的维度。
patch_size (int) – Patch Token 的大小。输入的空间维度必须能被 patch_size ** 5 整除（例如，当 patch_size=2 时能被 32 整除）。
feature_size (int) – 网络特征大小的维度。
depths (Sequence[int]) – 每个阶段的层数。
num_heads (Sequence[int]) – 注意力头的数量。
window_size (UnionType[Sequence[int], int]) – 局部窗口大小。
qkv_bias (bool) – 为 Query、Key、Value 添加可学习的偏置。
mlp_ratio (float) – MLP 隐藏层维度与嵌入维度的比例。
norm_name (UnionType[tuple, str]) – 特征归一化类型及参数。
drop_rate (float) – dropout 比率。
attn_drop_rate (float) – 注意力 dropout 比率。
dropout_path_rate (float) – Drop Path 比率。
normalize (bool) – 是否在每个阶段对输出的中间特征进行归一化。
norm_layer (type[LayerNorm]) – 归一化层。
patch_norm (bool) – 是否对 Patch Embedding 应用归一化。默认为 False。
use_checkpoint (bool) – 使用梯度检查点以减少内存使用。
spatial_dims (int) – 空间维度的数量。
downsample (UnionType[str, Module]) – 用于下采样的模块，可用选项为 “mergingv2”、“merging” 以及用户自定义的遵循 monai.networks.nets.PatchMerging 定义的 API 的 nn.Module。默认为 “merging”（v0.9.0 中定义的原始版本）。
use_v2 (bool) – 是否使用 swinunetr_v2，它在每个 Swin 阶段开始处添加了一个残差卷积块。

示例

# for 3D single channel input with size (96,96,96), 4-channel output and feature size of 48.
>>> net = SwinUNETR(in_channels=1, out_channels=4, feature_size=48)

# for 3D 4-channel input with size (128,128,128), 3-channel output and (2,4,2,2) layers in each stage.
>>> net = SwinUNETR(in_channels=4, out_channels=3, depths=(2,4,2,2))

# for 2D single channel input with size (96,96), 2-channel output and gradient checkpointing.
>>> net = SwinUNETR(in_channels=3, out_channels=2, use_checkpoint=True, spatial_dims=2)

引发异常:: ValueError – 当输入的空间维度不能被 patch_size ** 5 整除时抛出。在推理前使用 net._check_input_size(spatial_shape) 来验证形状。

forward(x_in)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

BasicUNet#

class monai.networks.nets.BasicUNet(spatial_dims=3, in_channels=1, out_channels=2, features=(32, 32, 64, 128, 256, 32), act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv')[源码]#

__init__(spatial_dims=3, in_channels=1, out_channels=2, features=(32, 32, 64, 128, 256, 32), act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv')[源码]#

支持 1D/2D/3D 的 UNet 实现。

基于

Falk 等人，“U-Net – Deep Learning for Cell Counting, Detection, and Morphometry”。Nature Methods 16, 67–70 (2019), DOI: http://dx.doi.org/10.1038/s41592-018-0261-2

参数:

spatial_dims (int) – 空间维度的数量。对于空间 3D 输入，默认为 3。
in_channels (int) – 输入通道数。默认为 1。
out_channels (int) – 输出通道数。默认为 2。
features (Sequence[int]) –
六个整数作为特征数量。默认为 (32, 32, 64, 128, 256, 32)，
- 前五个值对应于五级编码器特征的大小。
- 最后一个值对应于最后一次上采样后的特征大小。
act (UnionType[str, tuple]) – 激活类型及参数。默认为 LeakyReLU。
norm (UnionType[str, tuple]) – 特征归一化类型及参数。默认为实例归一化。
bias (bool) –
卷积块中是否有偏置项。默认为 True。根据性能调优指南，如果卷积层后直接跟随批归一化层，偏置应为 False。
dropout (UnionType[float, tuple]) – dropout 比率。默认为无 dropout。
upsample (str) – 上采样模式，可用选项包括 "deconv"、"pixelshuffle"、"nontrainable"。

示例

# for spatial 2D
>>> net = BasicUNet(spatial_dims=2, features=(64, 128, 256, 512, 1024, 128))

# for spatial 2D, with group norm
>>> net = BasicUNet(spatial_dims=2, features=(64, 128, 256, 512, 1024, 128), norm=("group", {"num_groups": 4}))

# for spatial 3D
>>> net = BasicUNet(spatial_dims=3, features=(32, 32, 64, 128, 256, 32))

另请参阅

monai.networks.nets.DynUNet

monai.networks.nets.UNet

forward(x)[source]#

参数:: x (Tensor) – 输入应具有空间 N 维度 (Batch, in_channels, dim_0[, dim_1, ..., dim_N-1])，N 由 spatial_dims 定义。建议满足 dim_n % 16 == 0，以确保所有最大池化输入具有偶数边长。
返回:: 形状为 (Batch, out_channels, dim_0[, dim_1, ..., dim_N-1]) 的“原始”预测的 Torch Tensor。

monai.networks.nets.BasicUnet[source]#: BasicUNet 的别名

monai.networks.nets.Basicunet[source]#: BasicUNet 的别名

BasicUNetPlusPlus#

class monai.networks.nets.BasicUNetPlusPlus(spatial_dims=3, in_channels=1, out_channels=2, features=(32, 32, 64, 128, 256, 32), deep_supervision=False, act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv')[source]#

__init__(spatial_dims=3, in_channels=1, out_channels=2, features=(32, 32, 64, 128, 256, 32), deep_supervision=False, act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv')[source]#

支持 1D/2D/3D 的 UNet++ 实现。

基于

Zhou 等人，“UNet++: A Nested U-Net Architecture for Medical Image Segmentation”。第 4 届医学图像分析深度学习 (DLMIA) 研讨会，DOI: https://doi.org/10.48550/arXiv.1807.10165

参数:

spatial_dims (int) – 空间维度的数量。对于空间 3D 输入，默认为 3。
in_channels (int) – 输入通道数。默认为 1。
out_channels (int) – 输出通道数。默认为 2。
features (Sequence[int]) –
六个整数作为特征数量。默认为 (32, 32, 64, 128, 256, 32)，
- 前五个值对应于五级编码器特征的大小。
- 最后一个值对应于最后一次上采样后的特征大小。
deep_supervision (bool) – 是否在推理时裁剪网络。默认为 False。如果为 true，则返回一个列表，其元素对应于不同节点的输出。
act (UnionType[str, tuple]) – 激活类型及参数。默认为 LeakyReLU。
norm (UnionType[str, tuple]) – 特征归一化类型及参数。默认为实例归一化。
bias (bool) –
卷积块中是否有偏置项。默认为 True。根据性能调优指南，如果卷积层后直接跟随批归一化层，偏置应为 False。
dropout (UnionType[float, tuple]) – dropout 比率。默认为无 dropout。
upsample (str) – 上采样模式，可用选项包括 "deconv"、"pixelshuffle"、"nontrainable"。

示例

# for spatial 2D
>>> net = BasicUNetPlusPlus(spatial_dims=2, features=(64, 128, 256, 512, 1024, 128))

# for spatial 2D, with deep supervision enabled
>>> net = BasicUNetPlusPlus(spatial_dims=2, features=(64, 128, 256, 512, 1024, 128), deep_supervision=True)

# for spatial 2D, with group norm
>>> net = BasicUNetPlusPlus(spatial_dims=2, features=(64, 128, 256, 512, 1024, 128), norm=("group", {"num_groups": 4}))

# for spatial 3D
>>> net = BasicUNetPlusPlus(spatial_dims=3, features=(32, 32, 64, 128, 256, 32))

另请参阅

monai.networks.nets.BasicUNet
monai.networks.nets.DynUNet
monai.networks.nets.UNet

forward(x)[source]#

参数:: x (Tensor) – 输入应具有空间 N 维度 (Batch, in_channels, dim_0[, dim_1, ..., dim_N-1])，N 由 dimensions 定义。建议满足 dim_n % 16 == 0，以确保所有最大池化输入具有偶数边长。
返回:: 形状为 (Batch, out_channels, dim_0[, dim_1, ..., dim_N-1]) 的“原始”预测的 Torch Tensor。

monai.networks.nets.BasicUnetPlusPlus[source]#: BasicUNetPlusPlus 的别名

monai.networks.nets.BasicunetPlusPlus[source]#: BasicUNetPlusPlus 的别名

FlexibleUNet#

class monai.networks.nets.FlexibleUNet(in_channels, out_channels, backbone, pretrained=False, decoder_channels=(256, 128, 64, 32, 16), spatial_dims=2, norm=('batch', {'eps': 0.001, 'momentum': 0.1}), act=('relu', {'inplace': True}), dropout=0.0, decoder_bias=False, upsample='nontrainable', pre_conv='default', interp_mode='nearest', is_pad=True)[source]#

一种类似 UNet 的编解码器架构的灵活实现。

__init__(in_channels, out_channels, backbone, pretrained=False, decoder_channels=(256, 128, 64, 32, 16), spatial_dims=2, norm=('batch', {'eps': 0.001, 'momentum': 0.1}), act=('relu', {'inplace': True}), dropout=0.0, decoder_bias=False, upsample='nontrainable', pre_conv='default', interp_mode='nearest', is_pad=True)[source]#

UNet 的一种灵活实现，其中骨干网/编码器可以用任何高效或残差网络替换。目前，输入必须具有 2 或 3 个空间维度，并且如果 is_pad 参数为 False，则每个维度的空间大小必须是 32 的倍数。请注意，骨干网的每个输出在最后一个输出的空间维度上必须进行 2 倍下采样。例如，如果给定 512x256 的 2D 图像和一个具有 4 个输出的骨干网，则每个编码器输出的空间大小应为 256x128、128x64、64x32 和 32x16。

参数:

in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
backbone (str) – 要初始化的骨干网名称，目前仅支持 efficientnet 和 resnet，可以是 [efficientnet-b0, …, efficientnet-b8, efficientnet-l2, resnet10, …, resnet200] 中的一种。
pretrained (bool) – 是否初始化预训练权重。如果 spatial_dims=2 且使用了批归一化，则 efficient 网络可使用 ImageNet 权重。如果 spatial_dims=3 且 in_channels=1，则残差网络可使用 MedicalNet 权重。默认为 False。
decoder_channels (tuple) – 解码器中所有特征图的输出通道数。len(decoder_channels) 应等于 len(encoder_channels) - 1，默认为 (256, 128, 64, 32, 16)。
spatial_dims (int) – 空间维度数，默认为 2。
norm (UnionType[str, tuple]) – 归一化类型和参数，默认为 (“batch”, {“eps”: 1e-3, “momentum”: 0.1})。
act (UnionType[str, tuple]) – 激活类型和参数，默认为 (“relu”, {“inplace”: True})。
dropout (UnionType[float, tuple]) – dropout 比率，默认为 0.0。
decoder_bias (bool) – 解码器的卷积块中是否具有偏置项。
upsample (str) – 上采样模式，可用选项为 "deconv"、"pixelshuffle"、"nontrainable"。
pre_conv (str) – 在上采样之前应用的卷积块。仅用于 “nontrainable” 或 “pixelshuffle” 模式，默认为 default。
interp_mode (str) – {"nearest", "linear", "bilinear", "bicubic", "trilinear"} 仅用于 “nontrainable” 模式。
is_pad (bool) – 是否填充上采样特征以匹配来自编码器的特征。默认为 True。如果此参数设置为 “True”，网络输入的空间维度可以是任意大小，而 TensorRT 不支持此功能。否则，它必须是 32 的倍数。

forward(inputs)[source]#

进行典型的编码器-解码器-头推理。

参数:: inputs (Tensor) – 输入应具有空间 N 维度 (Batch, in_channels, dim_0[, dim_1, ..., dim_N])，N 由 dimensions 定义。
返回:: 形状为 (Batch, out_channels, dim_0[, dim_1, ..., dim_N]) 的“原始”预测的 Torch Tensor。

VNet#

class monai.networks.nets.VNet(spatial_dims=3, in_channels=1, out_channels=1, act=('elu', {'inplace': True}), dropout_prob=0.5, dropout_prob_down=0.5, dropout_prob_up=(0.5, 0.5), dropout_dim=3, bias=False)[source]#

基于 Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation 的 V-Net。改编自官方 Caffe 实现以及另一个 pytorch 实现。该模型支持 2D 或 3D 输入。

参数:

spatial_dims (int) – 输入数据的空间维度。默认为 3。
in_channels (int) – 网络输入通道数。默认为 1。该值应满足 16 % in_channels == 0 的条件。
out_channels (int) – 网络输出通道数。默认为 1。
act (UnionType[tuple[str, dict], str]) – 网络中的激活类型。默认为 ("elu", {"inplace": True})。
dropout_prob_down (UnionType[float, None]) – DownTransition 块的 dropout 比率。默认为 0.5。
dropout_prob_up (tuple[UnionType[float, None], float]) – UpTransition 块的 dropout 比率。默认为 (0.5, 0.5)。
dropout_dim (int) –
确定 dropout 的维度。默认为 (0.5, 0.5)。
- dropout_dim = 1，随机将每个通道的一些元素归零。
- dropout_dim = 2，随机将整个通道归零（一个通道是一个 2D 特征图）。
- dropout_dim = 3，随机将整个通道归零（一个通道是一个 3D 特征图）。
bias (bool) –
卷积块中是否包含偏置项。默认为 False。根据性能调优指南，如果卷积层后面直接跟着批归一化层，则不应包含偏置。

版本 1.2 起已弃用：dropout_prob 已弃用，取而代之的是 dropout_prob_down 和 dropout_prob_up。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

RegUNet#

class monai.networks.nets.RegUNet(spatial_dims, in_channels, num_channel_initial, depth, out_kernel_initializer='kaiming_uniform', out_activation=None, out_channels=3, extract_levels=None, pooling=True, concat_skip=False, encode_kernel_sizes=3)[source]#

实现改编版 UNet 的类。此类同时作为 LocalNet 和 GlobalNet 的父类。

参考: O. Ronneberger, P. Fischer, and T. Brox, “U-net: Convolutional networks for biomedical image segmentation,”, Lecture Notes in Computer Science, 2015, vol. 9351, pp. 234–241. https://arxiv.org/abs/1505.04597
改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, in_channels, num_channel_initial, depth, out_kernel_initializer='kaiming_uniform', out_activation=None, out_channels=3, extract_levels=None, pooling=True, concat_skip=False, encode_kernel_sizes=3)[source]#

参数:

spatial_dims (int) – 空间维度数
in_channels (int) – 输入通道的数量
num_channel_initial (int) – 初始通道数
depth (int) – 输入位于 0 层，底层位于 depth 层。
out_kernel_initializer (UnionType[str, None]) – 最后一层的核初始化器
out_activation (Optional[str, None]) – 最后一层的激活
out_channels (int) – 输出通道数
extract_levels (Optional[tuple[int], None]) – 列表，指定要提取网络的哪些层。最大层级必须等于 depth
pooling (bool) – 若为真，则下采样使用非参数化池化，否则使用卷积
concat_skip (bool) – 若为真，则上采样时连接跳跃张量，否则使用加法
encode_kernel_sizes (UnionType[int, list[int]]) – 下采样的核大小

forward(x)[source]#

参数:: x – 形状为 (batch, in_channels, insize_1, insize_2, [insize_3]) 的张量
返回:: 形状为 (batch, out_channels, insize_1, insize_2, [insize_3]) 的张量，具有与 x 相同的空间尺寸

GlobalNet#

class monai.networks.nets.GlobalNet(image_size, spatial_dims, in_channels, num_channel_initial, depth, out_kernel_initializer='kaiming_uniform', out_activation=None, pooling=True, concat_skip=False, encode_kernel_sizes=3, save_theta=False)[source]#

构建用于图像配准的 GlobalNet。

参考: Hu, Yipeng, 等人。“Label-driven weakly-supervised learning for multimodal deformable image registration,” https://arxiv.org/abs/1711.01666

__init__(image_size, spatial_dims, in_channels, num_channel_initial, depth, out_kernel_initializer='kaiming_uniform', out_activation=None, pooling=True, concat_skip=False, encode_kernel_sizes=3, save_theta=False)[source]#

参数:

image_size (list[int]) – 输出位移场的空间大小
spatial_dims (int) – 空间维度数
in_channels (int) – 输入通道的数量
num_channel_initial (int) – 初始通道数
depth (int) – 输入位于 0 层，底层位于 depth 层。
out_kernel_initializer (UnionType[str, None]) – 最后一层的核初始化器
out_activation (Optional[str, None]) – 最后一层的激活
pooling (bool) – 若为真，则下采样使用非参数化池化，否则使用卷积
concat_skip (bool) – 若为真，则上采样时连接跳跃张量，否则使用加法
encode_kernel_sizes (UnionType[int, list[int]]) – 下采样的核大小
save_theta (bool) – 是否保存 theta 矩阵估计

LocalNet#

class monai.networks.nets.LocalNet(spatial_dims, in_channels, num_channel_initial, extract_levels, out_kernel_initializer='kaiming_uniform', out_activation=None, out_channels=3, pooling=True, use_additive_sampling=True, concat_skip=False, mode='nearest', align_corners=None)[source]#

LocalNet 的重新实现，基于：Weakly-supervised convolutional neural networks for multimodal image registration. Label-driven weakly-supervised learning for multimodal deformable image registration。

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, in_channels, num_channel_initial, extract_levels, out_kernel_initializer='kaiming_uniform', out_activation=None, out_channels=3, pooling=True, use_additive_sampling=True, concat_skip=False, mode='nearest', align_corners=None)[source]#

参数:

spatial_dims (int) – 空间维度数
in_channels (int) – 输入通道的数量
num_channel_initial (int) – 初始通道数
out_kernel_initializer (UnionType[str, None]) – 最后一层的核初始化器
out_activation (Optional[str, None]) – 最后一层的激活
out_channels (int) – 输出通道数
extract_levels (tuple[int]) – 列表，指定要提取网络的哪些层。最大层级必须等于 depth
pooling (bool) – 若为真，则下采样使用非参数化池化，否则使用 conv3d
use_additive_sampling (bool) – 是否使用加法上采样层进行解码。
concat_skip (bool) – 若为真，则上采样时连接跳跃张量，否则使用加法
mode (str) – 使用 additive_sampling 时的插值模式，默认为 “nearest”。
align_corners (Optional[bool, None]) – 使用 additive_sampling 时的插值 align_corners，默认为 None。

AutoEncoder#

class monai.networks.nets.AutoEncoder(spatial_dims, in_channels, out_channels, channels, strides, kernel_size=3, up_kernel_size=3, num_res_units=0, inter_channels=None, inter_dilations=None, num_inter_units=2, act='PRELU', norm='INSTANCE', dropout=None, bias=True, padding=None)[source]#

自动编码器的简单定义，以及实现 monai.networks.nets.VarAutoEncoder 的架构的基类。该网络由一系列编码块、随后的中间块序列以及最后的解码块序列组成。编码和解码块默认为 monai.networks.blocks.Convolution 的实例，编码块具有给定的步长，解码块具有具有相同步长的转置卷积。如果给出了 num_res_units，则改用残差块。

默认情况下中间序列为空，但如果给出了 inter_channels 来指定块的输出通道，则这将成为卷积块序列，或者如果给出了 num_inter_units，则成为残差块序列。可选参数 inter_dilations 可用于指定这些块中卷积的膨胀值，这允许网络在中间部分使用膨胀核。由于中间部分不打算改变输出的大小，因此所有这些核的步长均为 1。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
channels (Sequence[int]) – 通道序列。顶部块在前。channels 的长度应不少于 2。
strides (Sequence[int]) – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
up_kernel_size (UnionType[Sequence[int], int]) – 上采样卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
num_res_units (int) – 残差单元的数量。默认为 0。
inter_channels (Optional[list, None]) – 定义编码和解码之间中间层块的通道序列。
inter_dilations (Optional[list, None]) – 定义中间层每个块的膨胀值。默认为 1。
num_inter_units (int) – 中间层每个块的残差单元数。默认为 0。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为实例归一化。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
bias (bool) –
卷积块中是否有偏置项。默认为 True。根据性能调优指南，如果卷积层后直接跟随批归一化层，偏置应为 False。
padding (Union[Sequence[int], int, None]) – 控制卷积块中每个维度的点填充数量，用于两侧的隐式零填充。默认为 None。

示例

from monai.networks.nets import AutoEncoder

# 3 layers each down/up sampling their inputs by a factor 2 with no intermediate layer
net = AutoEncoder(
    spatial_dims=2,
    in_channels=1,
    out_channels=1,
    channels=(2, 4, 8),
    strides=(2, 2, 2)
)

# 1 layer downsampling by 2, followed by a sequence of residual units with 2 convolutions defined by
# progressively increasing dilations, then final upsample layer
net = AutoEncoder(
        spatial_dims=2,
        in_channels=1,
        out_channels=1,
        channels=(4,),
        strides=(2,),
        inter_channels=(8, 8, 8),
        inter_dilations=(1, 2, 4),
        num_inter_units=2
    )

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Any

VarAutoEncoder#

class monai.networks.nets.VarAutoEncoder(spatial_dims, in_shape, out_channels, latent_size, channels, strides, kernel_size=3, up_kernel_size=3, num_res_units=0, inter_channels=None, inter_dilations=None, num_inter_units=2, act='PRELU', norm='INSTANCE', dropout=None, bias=True, use_sigmoid=True)[source]#

基于论文 - https://arxiv.org/abs/1312.6114 的变分自动编码器。

参数:

spatial_dims (int) – 空间维度数量。
in_shape (Sequence[int]) – 输入数据的形状，从通道维度开始。
out_channels (int) – 输出通道数。
latent_size (int) – 潜在变量的大小。
channels (Sequence[int]) – 通道序列。顶部块在前。channels 的长度应不少于 2。
strides (Sequence[int]) – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size (UnionType[Sequence[int], int]) – 卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
up_kernel_size (UnionType[Sequence[int], int]) – 上采样卷积核大小，数值应为奇数。若是序列，其长度应等于维度数。默认为 3。
num_res_units (int) – 残差单元的数量。默认为 0。
inter_channels (Optional[list, None]) – 定义编码和解码之间中间层块的通道序列。
inter_dilations (Optional[list, None]) – 定义中间层每个块的膨胀值。默认为 1。
num_inter_units (int) – 中间层每个块的残差单元数。默认为 0。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为实例归一化。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
bias (bool) –
卷积块中是否有偏置项。默认为 True。根据性能调优指南，如果卷积层后直接跟随批归一化层，偏置应为 False。
use_sigmoid (bool) – 是否在最终输出上使用 sigmoid 函数。默认为 True。

示例

from monai.networks.nets import VarAutoEncoder

# 3 layer network accepting images with dimensions (1, 32, 32) and using a latent vector with 2 values
model = VarAutoEncoder(
    spatial_dims=2,
    in_shape=(32, 32),  # image spatial shape
    out_channels=1,
    latent_size=2,
    channels=(16, 32, 64),
    strides=(1, 2, 2),
)

另请参阅

带有 MedNIST 数据集的变分自动编码器网络 Project-MONAI/tutorials

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

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

ViT#

class monai.networks.nets.ViT(in_channels, img_size, patch_size, hidden_size=768, mlp_dim=3072, num_layers=12, num_heads=12, proj_type='conv', pos_embed_type='learnable', classification=False, num_classes=2, dropout_rate=0.0, spatial_dims=3, post_activation='Tanh', qkv_bias=False, save_attn=False)[source]#

Vision Transformer (ViT)，基于：“Dosovitskiy 等人，An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>”

ViT 支持 Torchscript，但仅适用于 1.8 之后的 Pytorch。

__init__(in_channels, img_size, patch_size, hidden_size=768, mlp_dim=3072, num_layers=12, num_heads=12, proj_type='conv', pos_embed_type='learnable', classification=False, num_classes=2, dropout_rate=0.0, spatial_dims=3, post_activation='Tanh', qkv_bias=False, save_attn=False)[source]#

参数:

in_channels (int) – 输入通道的维度。
img_size (Union[Sequence[int], int]) – 输入图像的维度。
patch_size (Union[Sequence[int], int]) – patch 大小的维度。
hidden_size (int, optional) – 隐藏层的维度。默认为 768。
mlp_dim (int, optional) – 前馈层的维度。默认为 3072。
num_layers (int, optional) – transformer 块的数量。默认为 12。
num_heads (int, optional) – 注意力头的数量。默认为 12。
proj_type (str, optional) – patch 嵌入层类型。默认为 “conv”。
pos_embed_type (str, optional) – 位置嵌入类型。默认为 “learnable”。
classification (bool, optional) – 布尔参数，用于确定是否使用分类。默认为 False。
num_classes (int, optional) – 如果使用分类，则为类别数量。默认为 2。
dropout_rate (float, optional) – 丢弃输入单元的比例。默认为 0.0。
spatial_dims (int, optional) – 空间维度数。默认为 3。
post_activation (str, optional) – 当 classification 为 True 时，向分类头添加最终激活函数。对于 nn.Tanh()，默认为 “Tanh”。设置为其他值可移除此函数。
qkv_bias (bool, optional) – 将偏置应用于自注意力块中的 qkv 线性层。默认为 False。
save_attn (bool, optional) – 使自注意力块中的注意力可访问。默认为 False。

示例

# for single channel input with image size of (96,96,96), conv position embedding and segmentation backbone
>>> net = ViT(in_channels=1, img_size=(96,96,96), proj_type='conv', pos_embed_type='sincos')

# for 3-channel with image size of (128,128,128), 24 layers and classification backbone
>>> net = ViT(in_channels=3, img_size=(128,128,128), proj_type='conv', pos_embed_type='sincos', classification=True)

# for 3-channel with image size of (224,224), 12 layers and classification backbone
>>> net = ViT(in_channels=3, img_size=(224,224), proj_type='conv', pos_embed_type='sincos', classification=True,
>>>           spatial_dims=2)

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

load_old_state_dict(old_state_dict, verbose=False)[source]#

加载使用较旧版本 MONAI 训练的 ViT 模型的 state dict，其中即使 with_cross_attention=False，CrossAttentionBlock 也会在 TransformerBlock 中被无条件实例化。旧检查点包含当前模型中不存在的陈旧 blocks.{i}.cross_attn.* 键，这些键会自动被丢弃。

参数:

old_state_dict (dict) – 旧 ViT 模型的 state dict。
verbose (bool) – 如果为 True，则打印缺失或不匹配的键。默认为 False。

返回类型:

None

Restormer#

monai.networks.nets.restormer[source]#: module ‘monai.networks.nets.restormer’ from ‘/home/docs/checkouts/readthedocs.org/user_builds/monai/checkouts/stable/monai/networks/nets/restormer.py’ 的别名

ViTAutoEnc#

class monai.networks.nets.ViTAutoEnc(in_channels, img_size, patch_size, out_channels=1, deconv_chns=16, hidden_size=768, mlp_dim=3072, num_layers=12, num_heads=12, proj_type='conv', dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[source]#

Vision Transformer (ViT)，基于：“Dosovitskiy 等人，An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>”

修改后还可以产生与图像输入大小相同的维度输出

__init__(in_channels, img_size, patch_size, out_channels=1, deconv_chns=16, hidden_size=768, mlp_dim=3072, num_layers=12, num_heads=12, proj_type='conv', dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[source]#

参数:

in_channels (int) – 输入通道的维度或输入通道数。
img_size (UnionType[Sequence[int], int]) – 输入图像的维度。
patch_size (UnionType[Sequence[int], int]) – patch 大小的维度
out_channels (int) – 输出通道数。默认为 1。
deconv_chns (int) – 反卷积层的通道数。默认为 16。
hidden_size (int) – 隐藏层的维度。默认为 768。
mlp_dim (int) – 前馈层的维度。默认为 3072。
num_layers (int) – transformer 块的数量。默认为 12。
num_heads (int) – 注意力头的数量。默认为 12。
proj_type (str) – 位置嵌入层类型。默认为 “conv”。
dropout_rate (float) – 输入单元的丢弃比例。默认为 0.0。
spatial_dims (int) – 空间维度数。默认为 3。
qkv_bias (bool) – 将偏置应用于自注意力块中的 qkv 线性层。默认为 False。
save_attn (bool) – 使自注意力块中的注意力可访问。默认为 False。

示例

# for single channel input with image size of (96,96,96), conv position embedding and segmentation backbone
# It will provide an output of same size as that of the input
>>> net = ViTAutoEnc(in_channels=1, patch_size=(16,16,16), img_size=(96,96,96), proj_type='conv')

# for 3-channel with image size of (128,128,128), output will be same size as of input
>>> net = ViTAutoEnc(in_channels=3, patch_size=(16,16,16), img_size=(128,128,128), proj_type='conv')

forward(x)[source]#

参数:: x – 输入张量必须具有各向同性的空间维度，例如 [batch_size, channels, sp_size, sp_size[, sp_size]]。

load_old_state_dict(old_state_dict, verbose=False)[source]#

加载使用较旧版本 MONAI 训练的 ViTAutoEnc 模型的 state dict，其中即使 with_cross_attention=False，CrossAttentionBlock 也会在 TransformerBlock 中被无条件实例化。旧检查点包含当前模型中不存在的陈旧 blocks.{i}.cross_attn.* 键，这些键会自动被丢弃。

参数:

old_state_dict (dict) – 旧 ViTAutoEnc 模型的 state dict。
verbose (bool) – 如果为 True，则打印缺失或不匹配的键。默认为 False。

返回类型:

None

MaskedAutoEncoderViT#

class monai.networks.nets.MaskedAutoEncoderViT(in_channels, img_size, patch_size, hidden_size=768, mlp_dim=512, num_layers=12, num_heads=12, masking_ratio=0.75, decoder_hidden_size=384, decoder_mlp_dim=512, decoder_num_layers=4, decoder_num_heads=12, proj_type='conv', pos_embed_type='sincos', decoder_pos_embed_type='sincos', dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[source]#

遮罩自动编码器 (ViT)，基于：“Kaiming 等人，Masked Autoencoders Are Scalable Vision Learners <https://arxiv.org/abs/2111.06377>” 只有一部分 patch 通过编码器。解码器尝试重建被遮罩的 patch，从而提高了训练速度。

__init__(in_channels, img_size, patch_size, hidden_size=768, mlp_dim=512, num_layers=12, num_heads=12, masking_ratio=0.75, decoder_hidden_size=384, decoder_mlp_dim=512, decoder_num_layers=4, decoder_num_heads=12, proj_type='conv', pos_embed_type='sincos', decoder_pos_embed_type='sincos', dropout_rate=0.0, spatial_dims=3, qkv_bias=False, save_attn=False)[source]#

参数:

in_channels (int) – 输入通道的维度或输入通道数。
img_size (UnionType[Sequence[int], int]) – 输入图像的维度。
patch_size (UnionType[Sequence[int], int]) – patch 大小的维度
hidden_size (int) – 隐藏层的维度。默认为 768。
mlp_dim (int) – 前馈层的维度。默认为 512。
num_layers (int) – transformer 块的数量。默认为 12。
num_heads (int) – 注意力头的数量。默认为 12。
masking_ratio (float) – 被遮罩的 patch 比率。默认为 0.75。
decoder_hidden_size (int) – 解码器隐藏层的维度。默认为 384。
decoder_mlp_dim (int) – 解码器前馈层的维度。默认为 512。
decoder_num_layers (int) – 解码器的 transformer 块数量。默认为 4。
decoder_num_heads (int) – 解码器的注意力头数量。默认为 12。
proj_type (str) – 位置嵌入层类型。默认为 “conv”。
pos_embed_type (str) – 位置嵌入层类型。默认为 “sincos”。
decoder_pos_embed_type (str) – 解码器的位置嵌入层类型。默认为 “sincos”。
dropout_rate (float) – 输入单元的丢弃比例。默认为 0.0。
spatial_dims (int) – 空间维度数。默认为 3。
qkv_bias (bool) – 将偏置应用于自注意力块中的 qkv 线性层。默认为 False。
save_attn (bool) – 是否使自注意力块中的注意力可访问。默认为 False。

示例：: # 针对图像尺寸为 (96,96,96) 的单通道输入，以及 sin-cos 位置编码 >>> net = MaskedAutoEncoderViT(in_channels=1, img_size=(96,96,96), patch_size=(16,16,16), pos_embed_type=’sincos’) # 针对图像尺寸为 (128,128,128) 的 3 通道输入，以及可学习的位置编码 >>> net = MaskedAutoEncoderViT(in_channels=3, img_size=128, patch_size=16, pos_embed_type=’learnable’) # 针对图像尺寸为 (224,224) 的 3 通道输入，以及 0.25 的掩码比例 >>> net = MaskedAutoEncoderViT(in_channels=3, img_size=(224,224), patch_size=(16,16), masking_ratio=0.25, spatial_dims=2)

forward(x, masking_ratio=None)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

load_old_state_dict(old_state_dict, verbose=False)[源码]#

从使用旧版本 MONAI 训练的 MaskedAutoEncoderViT 模型加载状态字典。在旧版本中，即使 with_cross_attention=False，CrossAttentionBlock 也会在 TransformerBlock 中被无条件实例化。旧检查点包含陈旧的 blocks.{i}.cross_attn.* 和 decoder_blocks.{i}.cross_attn.* 键，这些键在当前模型中不存在，将被自动丢弃。

参数:

old_state_dict (dict) – 来自旧 MaskedAutoEncoderViT 模型的状态字典。
verbose (bool) – 如果为 True，则打印缺失或不匹配的键。默认为 False。

返回类型:

None

FullyConnectedNet#

class monai.networks.nets.FullyConnectedNet(in_channels, out_channels, hidden_channels, dropout=None, act='PRELU', bias=True, adn_ordering=None)[源码]#

简单的全连接层神经网络，由一系列带有 PReLU 激活函数和 dropout 的线性层组成。该网络接受具有 in_channels 通道的输入，输出为具有 out_channels 通道的输出，隐藏层输出通道数由 hidden_channels 指定。如果 bias 为 True，则线性单元具有偏置项。

参数:

in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
hidden_channels (Sequence[int]) – 每个隐藏层的输出通道数。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
bias (bool) – 线性单元是否包含偏置项。默认为 True。
adn_ordering (Optional[str, None]) – monai.networks.blocks.ADN 中的操作顺序。

示例

# accepts 4 values and infers 3 values as output, has 3 hidden layers with 10, 20, 10 values as output
net = FullyConnectedNet(4, 3, [10, 20, 10], dropout=0.2)

__init__(in_channels, out_channels, hidden_channels, dropout=None, act='PRELU', bias=True, adn_ordering=None)[源码]#: 定义一个网络，该网络接受具有 in_channels 通道的输入，输出为 out_channels 个通道，并使用 hidden_channels 指定的通道数定义隐藏层。如果 bias 为 True，则线性单元具有偏置项。

VarFullyConnectedNet#

class monai.networks.nets.VarFullyConnectedNet(in_channels, out_channels, latent_size, encode_channels, decode_channels, dropout=None, act='PRELU', bias=True, adn_ordering=None)[源码]#

变分全连接网络。它由编码层、重参数化层和解码层组成。

参数:

in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
latent_size (int) – 要使用的潜在变量数量。
encode_channels (Sequence[int]) – 编码部分每个隐藏层的输出通道数。
decode_channels (Sequence[int]) – 解码部分每个隐藏层的输出通道数。
dropout (Union[tuple, str, float, None]) – 丢弃率。默认为无丢弃。
act (UnionType[tuple, str, None]) – 激活类型及参数。默认为 PReLU。
bias (bool) – 线性单元是否包含偏置项。默认为 True。
adn_ordering (Optional[str, None]) – monai.networks.blocks.ADN 中的操作顺序。

示例

# accepts inputs with 4 values, uses a latent space of 2 variables, and produces outputs of 3 values
net = VarFullyConnectedNet(4, 3, 2, [5, 10], [10, 5])

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

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

Generator#

class monai.networks.nets.Generator(latent_shape, start_shape, channels, strides, kernel_size=3, num_res_units=2, act='PRELU', norm='INSTANCE', dropout=None, bias=True)[源码]#

定义一个简单的生成器网络，它接受一个潜在向量，并通过一系列卷积层构建一个尺寸更大且具有高维度的输出张量。_get_layer 方法用于创建这些层中的每一层，重写此方法可以定义除默认 monai.networks.blocks.Convolution 或 monai.networks.blocks.ResidualUnit 层之外的其他层。

这些层是使用 channels 和 strides 参数中的值构建的，层的数量由这些参数的长度决定（必须匹配）。输入首先通过一个 torch.nn.Linear 层，将输入向量转换为尺寸为 start_shape 的图像张量。该张量通过卷积层，如果 strides 的值大于 1，则使用转置卷积进行渐进式上采样。最终输出的大小由 start_shape 维度和通过 strides 进行的上采样量决定。在默认定义中，输出的空间维度大小将是 start_shape 乘以 strides 的乘积。因此，下面的示例网络将起始尺寸为 (64, 8, 8) 的输入上采样至 (1, 64, 64)，因为其 strides 为 (2, 2, 2)。

参数:

latent_shape (Sequence[int]) – 表示输入潜在向量维度（减去 batch 维度）的整数元组。
start_shape (Sequence[int]) – 表示传递给卷积子网的张量维度的整数元组。
channels (Sequence[int]) – 表示每个卷积层输出通道数的整数元组。
strides (Sequence[int]) – 表示每个卷积层步长（上采样因子）的整数元组。
kernel_size (UnionType[Sequence[int], int]) – 表示卷积核大小的整数或整数元组。
num_res_units (int) – 表示残差单元中卷积层数量的整数，0 表示没有残差单元。
act – 定义激活层的名称或类型。
norm – 定义归一化层的名称或类型。
dropout (Optional[float, None]) – 可选的 [0, 1] 范围内的浮点值，表示层的 dropout 概率，None 表示不使用 dropout。
bias (bool) – 布尔值，表示卷积层是否应包含偏置项。

示例

# 3 layers, latent input vector of shape (42, 24), output volume of shape (1, 64, 64)
net = Generator((42, 24), (64, 8, 8), (32, 16, 1), (2, 2, 2))

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Regressor#

class monai.networks.nets.Regressor(in_shape, out_shape, channels, strides, kernel_size=3, num_res_units=2, act='PRELU', norm='INSTANCE', dropout=None, bias=True)[源码]#

定义了一个用于关联大尺寸输入张量和小尺寸输出张量的网络，即回归大数值到预测值。单维度的输出可用于数值回归或多标签分类预测，单数值输出可用于判别器或评判器预测。

该网络被构造为一系列层（monai.networks.blocks.Convolution 或 monai.networks.blocks.ResidualUnit），最后通过一个全连接层将模块的输出重塑为最终尺寸。每个块都定义有一个步长值，通常用于通过带步长的卷积下采样输入。通过这种方式，每个块将输入的信息渐进地凝练为深度表示，最终由全连接层关联至最终结果。

参数:

in_shape (Sequence[int]) – 表示输入张量维度（减去 batch 维度）的整数元组。
out_shape (Sequence[int]) – 表示最终输出张量维度（减去 batch 维度）的整数元组。
channels (Sequence[int]) – 表示每个卷积层输出通道数的整数元组。
strides (Sequence[int]) – 表示每个卷积层步长（下采样因子）的整数元组。
kernel_size (UnionType[Sequence[int], int]) – 表示卷积核大小的整数或整数元组。
num_res_units (int) – 表示残差单元中卷积层数量的整数，0 表示没有残差单元。
act – 定义激活层的名称或类型。
norm – 定义归一化层的名称或类型。
dropout (Optional[float, None]) – 可选的 [0, 1] 范围内的浮点值，表示层的 dropout 概率，None 表示不使用 dropout。
bias (bool) – 布尔值，表示卷积层是否应包含偏置项。

示例

# infers a 2-value result (eg. a 2D cartesian coordinate) from a 64x64 image
net = Regressor((1, 64, 64), (2,), (2, 4, 8), (2, 2, 2))

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Classifier#

class monai.networks.nets.Classifier(in_shape, classes, channels, strides, kernel_size=3, num_res_units=2, act='PRELU', norm='INSTANCE', dropout=None, bias=True, last_act=None)[源码]#

通过指定输出形状为与类数大小相等的单维张量，从 Regressor 定义一个分类网络。最终的激活函数也可以指定，例如 softmax 或 sigmoid。

参数:

in_shape (Sequence[int]) – 表示输入张量维度（减去 batch 维度）的整数元组。
classes (int) – 表示最终输出张量维度的整数。
channels (Sequence[int]) – 表示每个卷积层输出通道数的整数元组。
strides (Sequence[int]) – 表示每个卷积层步长（下采样因子）的整数元组。
kernel_size (UnionType[Sequence[int], int]) – 表示卷积核大小的整数或整数元组。
num_res_units (int) – 表示残差单元中卷积层数量的整数，0 表示没有残差单元。
act – 定义激活层的名称或类型。
norm – 定义归一化层的名称或类型。
dropout (Optional[float, None]) – 可选的 [0, 1] 范围内的浮点值，表示层的 dropout 概率，None 表示不使用 dropout。
bias (bool) – 布尔值，表示卷积层是否应包含偏置项。
last_act (Optional[str, None]) – 定义最后一个激活层的名称。

Discriminator#

class monai.networks.nets.Discriminator(in_shape, channels, strides, kernel_size=3, num_res_units=2, act='PRELU', norm='INSTANCE', dropout=0.25, bias=True, last_act='SIGMOID')[源码]#

从 Classifier 定义一个判别器网络，默认具有单个输出值和 sigmoid 激活。这旨在用于 GANs 或其他需要通用判别器网络的应用。

参数:

in_shape (Sequence[int]) – 表示输入张量维度（减去 batch 维度）的整数元组。
channels (Sequence[int]) – 表示每个卷积层输出通道数的整数元组。
strides (Sequence[int]) – 表示每个卷积层步长（下采样因子）的整数元组。
kernel_size (UnionType[Sequence[int], int]) – 表示卷积核大小的整数或整数元组。
num_res_units (int) – 表示残差单元中卷积层数量的整数，0 表示没有残差单元。
act – 定义激活层的名称或类型。
norm – 定义归一化层的名称或类型。
dropout (UnionType[float, None]) – 可选的 [0, 1] 范围内的浮点值，表示层的 dropout 概率，None 表示不使用 dropout。
bias (bool) – 布尔值，表示卷积层是否应包含偏置项。
last_act – 定义最后一个激活层的名称。

Critic#

class monai.networks.nets.Critic(in_shape, channels, strides, kernel_size=3, num_res_units=2, act='PRELU', norm='INSTANCE', dropout=0.25, bias=True)[源码]#

从 Classifier 定义一个评判器网络，具有单个输出值且没有最终激活函数。最后一层是 nn.Flatten 而不是 nn.Linear，最终结果计算为第一维的平均值。这旨在与 Wasserstein GANs 一起使用。

参数:

in_shape (Sequence[int]) – 表示输入张量维度（减去 batch 维度）的整数元组。
channels (Sequence[int]) – 表示每个卷积层输出通道数的整数元组。
strides (Sequence[int]) – 表示每个卷积层步长（下采样因子）的整数元组。
kernel_size (UnionType[Sequence[int], int]) – 表示卷积核大小的整数或整数元组。
num_res_units (int) – 表示残差单元中卷积层数量的整数，0 表示没有残差单元。
act – 定义激活层的名称或类型。
norm – 定义归一化层的名称或类型。
dropout (UnionType[float, None]) – 可选的 [0, 1] 范围内的浮点值，表示层的 dropout 概率，None 表示不使用 dropout。
bias (bool) – 布尔值，表示卷积层是否应包含偏置项。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

Transchex#

class monai.networks.nets.Transchex(in_channels, img_size, patch_size, num_classes, num_language_layers, num_vision_layers, num_mixed_layers, hidden_size=768, drop_out=0.0, attention_probs_dropout_prob=0.1, gradient_checkpointing=False, hidden_act='gelu', hidden_dropout_prob=0.1, initializer_range=0.02, intermediate_size=3072, layer_norm_eps=1e-12, max_position_embeddings=512, model_type='bert', num_attention_heads=12, num_hidden_layers=12, pad_token_id=0, position_embedding_type='absolute', transformers_version='4.10.2', type_vocab_size=2, use_cache=True, vocab_size=30522, chunk_size_feed_forward=0, is_decoder=False, add_cross_attention=False, path_or_repo_id='bert-base-uncased', filename='pytorch_model.bin')[源码]#

TransChex 基于：“Hatamizadeh et al., TransCheX: Self-Supervised Pretraining of Vision-Language Transformers for Chest X-ray Analysis”

__init__(in_channels, img_size, patch_size, num_classes, num_language_layers, num_vision_layers, num_mixed_layers, hidden_size=768, drop_out=0.0, attention_probs_dropout_prob=0.1, gradient_checkpointing=False, hidden_act='gelu', hidden_dropout_prob=0.1, initializer_range=0.02, intermediate_size=3072, layer_norm_eps=1e-12, max_position_embeddings=512, model_type='bert', num_attention_heads=12, num_hidden_layers=12, pad_token_id=0, position_embedding_type='absolute', transformers_version='4.10.2', type_vocab_size=2, use_cache=True, vocab_size=30522, chunk_size_feed_forward=0, is_decoder=False, add_cross_attention=False, path_or_repo_id='bert-base-uncased', filename='pytorch_model.bin')[源码]#

参数:

in_channels (int) – 输入通道的维度。
img_size (UnionType[Sequence[int], int]) – 输入图像的维度。
patch_size (UnionType[int, tuple[int, int]]) – patch 大小的维度。
num_classes (int) – 如果使用分类，则为类别数量。
num_language_layers (int) – 语言 transformer 层的数量。
num_vision_layers (int) – 视觉 transformer 层的数量。
num_mixed_layers (int) – 混合 transformer 层的数量。
drop_out (float) – 要丢弃的输入单元的比例。
path_or_repo_id (UnionType[str, PathLike]) – 这可以是：- 一个字符串，huggingface.co 上模型仓库的 模型 ID。- 包含文件的潜在目录的路径。
filename (str) – 在 path_or_repo 中定位的文件名称。

其他参数是 MultiModal.from_pretrained 中 bert_config 的一部分。

示例

# for 3-channel with image size of (224,224), patch size of (32,32), 3 classes, 2 language layers,
# 2 vision layers, 2 mixed modality layers and dropout of 0.2 in the classification head
net = Transchex(in_channels=3,
                     img_size=(224, 224),
                     num_classes=3,
                     num_language_layers=2,
                     num_vision_layers=2,
                     num_mixed_layers=2,
                     drop_out=0.2)

forward(input_ids, token_type_ids=None, vision_feats=None)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

NetAdapter#

class monai.networks.nets.NetAdapter(model, num_classes=1, dim=2, in_channels=None, use_conv=False, pool=('avg', {'kernel_size': 7, 'stride': 1}), bias=True, fc_name='fc', node_name='')[源码]#

包装器，用于使用卷积层或全连接（FC）层替换模型的最后一层。

参见：monai.networks.nets.TorchVisionFCModel

参数:

model (Module) – 一个 PyTorch 模型，可以是 2D 或 3D 模型。通常，它可以是 Torchvision 中的预训练模型，如：resnet18, resnet34, resnet50, resnet101, resnet152 等。更多详细信息：https://pytorch.ac.cn/vision/stable/models.html。
num_classes (int) – 最后一个分类层的类别数量。默认为 1。
dim (int) – 指定模型中支持的空间维度数量，取决于模型的实现。默认为 2，因为大多数 Torchvision 模型用于 2D 图像处理。
in_channels (Optional[int, None]) – 最后一层的输入通道数。如果为 None，则从最后一层的 in_features 获取。
use_conv (bool) – 是否使用卷积层替换最后一层，默认为 False。
pool (UnionType[tuple[str, dict[str, Any]], None]) – 池化层的参数，应为一个元组，第一项是池化层的名称，第二项是初始化参数的字典。如果为 None，则不会替换 layers[-2]。默认为 (“avg”, {“kernel_size”: 7, “stride”: 1})。
bias (bool) – 替换最后一层时的偏置值。如果为 False，则该层将不会学习加性偏置，默认为 True。
fc_name (str) – 最后一个全连接层的对应层属性。默认为 "fc"。
node_name (str) – model 的相应特征提取器节点名称。默认为 “”，即不使用提取器。

forward(x)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

TorchVisionFCModel#

class monai.networks.nets.TorchVisionFCModel(model_name='resnet18', num_classes=1, dim=2, in_channels=None, use_conv=False, pool=('avg', {'kernel_size': 7, 'stride': 1}), bias=True, pretrained=False, fc_name='fc', node_name='', weights=None, **kwargs)[源码]#

自定义（预训练）TorchVision 模型的全连接层，或用卷积层替换它。

此类支持两种主要用例：

使用 pool=None 表示不修改池化层。它应与 fc_name 一起使用以定位要修改的目标 FC 层：在这种情况下，该类将加载一个 torchvision 分类模型，并用一个新的、具有 num_classes 输出的 FC 层替换最后一个全连接 (FC) 层。示例输入参数：use_conv=False, pool=None, fc_name="heads.head"。heads.head 指定了输入模型的目标 FC，可以通过 model.named_modules() 找到。
from torchvision.models import vit_b_16
print([name[0] for name in vit_b_16().named_modules()])
使用 pool="" 或将其设置为池化参数元组，以表示对池化层和 FC 层都进行修改。它应与 node_name 一起使用以定位模型特征输出：在这种情况下，该类将加载一个 torchvision 模型，删除现有的池化和 FC 层，并

添加一个额外的卷积层：use_conv=True, pool="", node_name="permute"

添加额外的池化和 FC 层：use_conv=False, pool=("avg", {"kernel_size": 7, "stride": 1}), node_name="permute"

添加额外的池化和卷积层：use_conv=True, pool=("avg", {"kernel_size": 7, "stride": 1}), node_name="permute"

示例中的 permute 是输入 model_name 的目标特征提取节点，可以通过使用 torchvision 特征提取工具找到。
from torchvision.models.feature_extraction import get_graph_node_names
from torchvision.models import swin_t
print(get_graph_node_names(swin_t())[0])

参数:

model_name (str) – 任何在最后具有全连接层的 torchvision 模型的名称。resnet18 (默认), resnet34, resnet50, resnet101, resnet152, resnext50_32x4d, resnext101_32x8d, wide_resnet50_2, wide_resnet101_2, inception_v3。模型详细信息：https://pytorch.ac.cn/vision/stable/models.html。
num_classes (int) – 最后一个分类层的类别数量。默认为 1。
dim (int) – 指定模型中支持的空间维度数量，取决于模型的实现。默认为 2，因为大多数 Torchvision 模型用于 2D 图像处理。
in_channels (Optional[int, None]) – 最后一层的输入通道数。如果为 None，则从最后一层的 in_features 获取。
use_conv (bool) – 是否使用卷积层替换最后一层，默认为 False。
pool (UnionType[tuple[str, dict[str, Any]], None]) – 池化层的参数，当它是一个元组时，第一项是池化层的名称，第二项是初始化参数的字典。如果为 None，则不会替换 layers[-2]。默认为 (“avg”, {“kernel_size”: 7, “stride”: 1})。"" 表示不添加池化层。
bias (bool) – 替换最后一层时的偏置值。如果为 False，则该层将不会学习加性偏置，默认为 True。
pretrained (bool) – 是否使用 imagenet 预训练权重。默认为 False。
fc_name (str) – 最后一个全连接层的对应层属性。默认为 "fc"。
node_name (str) – model 的相应特征提取器节点名称。默认为 “”，即不使用。
weights – torchvision 模型的附加权重枚举。
kwargs – torchvision 模型的附加参数。

示例

import torch
from torchvision.models.inception import Inception_V3_Weights

from monai.networks.nets import TorchVisionFCModel

model = TorchVisionFCModel(
    "inception_v3",
    num_classes=4,
    weights=Inception_V3_Weights.IMAGENET1K_V1,
    use_conv=False,
    pool=None,
)
# model = TorchVisionFCModel("vit_b_16", num_classes=4, pool=None, in_channels=768, fc_name="heads")
output = model.forward(torch.randn(2, 3, 299, 299))
print(output.shape)  # torch.Size([2, 4])

MILModel#

class monai.networks.nets.MILModel(num_classes, mil_mode='att', pretrained=True, backbone=None, backbone_num_features=None, trans_blocks=4, trans_dropout=0.0)[源码]#

多示例学习 (MIL) 模型，具有骨干分类模型。目前，它仅适用于 2D 图像，典型用例是数字病理学全切片图像的分类。输入数据的预期形状为 [B, N, C, H, W]，其中 B 是 PyTorch Dataloader 的 batch_size，N 是从批次中每张原始图像提取的示例数。教程示例位于：Project-MONAI/tutorials。

参数:

num_classes (int) – 输出类别数。
mil_mode (str) –
MIL 算法，可用值（默认为 "att"）
- "mean" - 所有示例的平均特征，等同于纯 CNN（非 MIL）。
- "max" - 仅保留损失计算中最大概率的示例。
- "att" - 基于注意力的 MIL https://arxiv.org/abs/1802.04712。
- "att_trans" - transformer MIL https://arxiv.org/abs/2111.01556。
- "att_trans_pyramid" - transformer 金字塔 MIL https://arxiv.org/abs/2111.01556。
pretrained (bool) – 使用预训练权重初始化骨干网络，默认为 True。
backbone (Union[str, Module, None]) – 骨干分类器 CNN（可以是 None，一个返回特征的 nn.Module，或者 torchvision 模型的字符串名称）。默认为 None，此时使用 ResNet50。
backbone_num_features (Optional[int, None]) – 骨干 CNN 的输出特征数量，默认为 None（仅在使用自定义骨干网络时需要）。
trans_blocks (int) – TransformEncoder 层中的块数量。
trans_dropout (float) – TransformEncoder 层中的 dropout 率。

forward(x, no_head=False)[源码]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

DiNTS#

class monai.networks.nets.DiNTS(dints_space, in_channels, num_classes, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), spatial_dims=3, use_downsample=True, node_a=None)[源码]#

基于 “DiNTS: Differentiable Neural Network Topology Search for 3D Medical Image Segmentation <https://arxiv.org/abs/2103.15954>” 对 DiNTS 的重新实现。

该模型包含一个预定义的多分辨率 stem 块（在此类中定义）和一个 DiNTS 空间（在 monai.networks.nets.TopologyInstance 和 monai.networks.nets.TopologySearch 中定义）。

stem 块用于：1) 输入下采样，2) 输出上采样至原始尺寸。该模型将输入图像下采样 2 倍（如果 use_downsample=True）。下采样后的图像进一步下采样 [1, 2, 4, 8] 倍（num_depths=4），并用作 DiNTS 搜索空间 (TopologySearch) 或 DiNTS 实例 (TopologyInstance) 的输入。

TopologyInstance 是最终搜索到的模型。初始化需要搜索到的架构代码。

TopologySearch 是一个多路径拓扑和单元操作搜索空间。架构代码将被初始化为 1。

TopologyConstruction 是构建实例和搜索空间的父类。

为了满足结构要求，每个空间维度的输入大小应该：可被 2 ** (num_depths + 1) 整除。

参数:

dints_space – DiNTS 搜索空间。该值应该是 TopologyInstance 或 TopologySearch 的实例。
in_channels (int) – 输入图像通道数。
num_classes (int) – 输出分割类别数量。
act_name (UnionType[tuple, str]) – 激活函数名称，默认为 ‘RELU’。
norm_name (UnionType[tuple, str]) – 卷积块中使用的归一化方法。默认为 InstanceNorm。
spatial_dims (int) – 空间 2D 或 3D 输入。
use_downsample (bool) – 是否在 stem 中使用下采样。如果为 False，搜索空间分辨率为 [1, 1/2, 1/4, 1/8]；如果为 True，搜索空间分辨率为 [1/2, 1/4, 1/8, 1/16]。
node_a – 节点激活 numpy 矩阵。其形状为 (num_depths, num_blocks + 1)，+1 表示多分辨率输入。在模型搜索阶段，node_a 可以为 None。在部署阶段，node_a 不能为 None。

forward(x)[source]#

基于动态 arch_code 的预测。

参数:: x (Tensor) – 输入张量。

DiNTS 的拓扑构建 (TopologyConstruction)#

class monai.networks.nets.TopologyConstruction(arch_code=None, channel_mul=1.0, cell=<class 'monai.networks.nets.dints.Cell'>, num_blocks=6, num_depths=3, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), use_downsample=True, device='cpu')[source]#

TopologyInstance 和 TopologySearch 的基类。

参数:

arch_code (Optional[list, None]) –
[arch_code_a, arch_code_c]，numpy 数组。定义模型的架构代码。例如，对于 num_depths=4, num_blocks=12 的搜索空间：
- arch_code_a 是一个 12x10（10 条路径）的二进制矩阵，表示路径是否激活。
- arch_code_c 是一个 12x10x5（5 种操作）的二进制矩阵，表示是否使用了某个单元操作。
- __init__() 中的 arch_code 用于创建网络并移除未使用的网络块。如果为 None，
则将使用所有路径和单元操作，并且必须处于搜索阶段 (is_search=True)。
channel_mul (float) – 调整中间通道数，默认为 1。
cell – 每个节点的操作。
num_blocks (int) – DiNTS 搜索空间的块数（水平方向的深度）。
num_depths (int) – DiNTS 搜索空间的图像分辨率数量：每个维度为 1, 1/2, 1/4 …
use_downsample (bool) – 是否在 stem 中使用下采样。如果为 False，搜索空间分辨率为 [1, 1/2, 1/4, 1/8]；如果为 True，搜索空间分辨率为 [1/2, 1/4, 1/8, 1/16]。
device (str) – ‘cpu’, ‘cuda’ 或设备 ID。

预定义变量

filter_nums: 默认为 32。下采样后通道数加倍。拓扑相关变量

arch_code2in: 路径激活到其输入节点索引（分辨率）。对于深度 = 4，arch_code2in = [0, 1, 0, 1, 2, 1, 2, 3, 2, 3]。第一条路径从节点 0（最高分辨率）输出，第二条路径从节点 1（搜索空间中的第二分辨率）输出，第三条路径从节点 0 输出，以此类推。

arch_code2ops: 路径激活到上采样 1、保持 0、下采样 -1 的操作。对于深度 = 4，arch_code2ops = [0, 1, -1, 0, 1, -1, 0, 1, -1, 0]。第一条路径不改变分辨率，第二条路径执行上采样，第三条执行下采样，以此类推。

arch_code2out: 路径激活到其输出节点索引。对于深度 = 4，arch_code2out = [0, 0, 1, 1, 1, 2, 2, 2, 3, 3]，第一和第二条路径连接到节点 0（最高分辨率），第 3,4,5 条路径连接到节点 1，以此类推。

forward(x)[source]#: 此函数由架构实例或搜索空间实现。

DiNTS 的拓扑实例 (TopologyInstance)#

class monai.networks.nets.TopologyInstance(arch_code=None, channel_mul=1.0, cell=<class 'monai.networks.nets.dints.Cell'>, num_blocks=6, num_depths=3, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), use_downsample=True, device='cpu')[source]#

最终搜索架构的实例。仅用于再训练/推理阶段。

__init__(arch_code=None, channel_mul=1.0, cell=<class 'monai.networks.nets.dints.Cell'>, num_blocks=6, num_depths=3, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), use_downsample=True, device='cpu')[source]#: 初始化 DiNTS 神经架构拓扑搜索空间。

forward(x)[source]#

参数:: x (list[Tensor]) – 输入张量。
返回类型:: list[Tensor]

DiNTS 的拓扑搜索 (TopologySearch)#

class monai.networks.nets.TopologySearch(channel_mul=1.0, cell=<class 'monai.networks.nets.dints.Cell'>, arch_code=None, num_blocks=6, num_depths=3, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), use_downsample=True, device='cpu')[source]#

DiNTS 神经架构拓扑搜索空间。

示例

from monai.networks.nets.dints import TopologySearch

topology_search_space = TopologySearch(
    channel_mul=0.5, num_blocks=8, num_depths=4, use_downsample=True, spatial_dims=3)
topology_search_space.get_ram_cost_usage(in_size=(2, 16, 80, 80, 80), full=True)
multi_res_images = [
    torch.randn(2, 16, 80, 80, 80),
    torch.randn(2, 32, 40, 40, 40),
    torch.randn(2, 64, 20, 20, 20),
    torch.randn(2, 128, 10, 10, 10)]
prediction = topology_search_space(image)
for x in prediction: print(x.shape)
# torch.Size([2, 16, 80, 80, 80])
# torch.Size([2, 32, 40, 40, 40])
# torch.Size([2, 64, 20, 20, 20])
# torch.Size([2, 128, 10, 10, 10])

类方法概览

get_prob_a(): 将可学习的架构权重转换为路径激活概率。

get_ram_cost_usage(): 获取估计的内存开销。

get_topology_entropy(): 获取搜索阶段的拓扑熵损失。

decode(): 获取最终二值化的架构代码。

gen_mtx(): 生成拓扑搜索所需的变量。

预定义变量

tidx: 用于将 transfer_mtx 中的路径激活矩阵 T = (depth,depth) 转换为路径激活 arch_code (1,3*depth-2) 的索引。对于深度 = 4，tidx = [0, 1, 4, 5, 6, 9, 10, 11, 14, 15]。一个 tidx (10 个二进制值) 表示路径激活。
transfer_mtx: 给定节点激活模式时的可行路径激活矩阵（记为 T）。用于将路径激活模式 (1, 路径数) 转换为节点激活 (1, 节点数)。
node_act_list: 所有节点激活 [2^num_depths-1, depth]。对于深度 = 4，有 15 种节点激活模式，每种长度为 4。例如，[1,1,0,0] 表示节点 0、1 已激活（带有输入路径）。
all_connect: 所有可能的路径激活。对于深度 = 4，all_connection 包含 1024 个长度为 10（10 条路径）的向量。返回值将排除全 0 的路径激活。

__init__(channel_mul=1.0, cell=<class 'monai.networks.nets.dints.Cell'>, arch_code=None, num_blocks=6, num_depths=3, spatial_dims=3, act_name='RELU', norm_name=('INSTANCE', {'affine': True}), use_downsample=True, device='cpu')[source]#: 初始化 DiNTS 神经架构拓扑搜索空间。

decode()[source]#

使用 Dijkstra 最短路径算法解码网络 log_alpha_a/log_alpha_c。

使用 self.decode() 时解码出 [node_a, arch_code_a, arch_code_c, arch_code_a_max]。

例如，对于 num_depths=4, num_blocks=12 的搜索空间：

node_a 是一个 4x13 的二进制矩阵，表示特征节点是否激活（13 是因为有多个分辨率输入）。

arch_code_a 是一个 12x10（10 条路径）的二进制矩阵，表示路径是否激活。

arch_code_c 是一个 12x10x5（5 种操作）的二进制矩阵，表示是否使用了某个单元操作。

返回:: 具有最大概率的 arch_code

forward(x)[source]#

基于动态 arch_code 的预测。

参数:: x – 一个包含 num_depths 个张量的列表，作为多分辨率输入。张量形状为 BCHW[D]，其中 C 必须与 self.filter_nums 匹配。

gen_mtx(depth)[source]#

生成解码和拓扑所需的元素。

transfer_mtx: 给定节点激活模式时的可行路径激活矩阵（记为 T）。
用于将路径激活模式 (1, 路径数) 转换为节点激活 (1, 节点数)。

node_act_list: 所有节点激活 [2^num_depths-1, depth]。对于深度 = 4，有 15 种节点激活
模式，每种长度为 4。例如，[1,1,0,0] 表示节点 0、1 已激活（带有输入路径）。

all_connect: 所有可能的路径激活。对于深度 = 4，all_connection 包含 1024 个长度为 10（10 条路径）的向量。返回值将排除全 0 的路径激活。

get_prob_a(child=False)[source]#

根据架构权重 log_alpha_a 获取最终路径和子模型概率。这用于前向传递、获取训练损失和最终解码。

参数:

child (bool) – 返回子模型概率（用于解码）

返回:

大小为: [块数, 每个块的路径数] 的路径激活概率。对于 12 个块、4 个深度的搜索空间，大小为 [12,10]。
probs_a: 所有子模型的概率（大小 1023x10）。每个子模型都是一个路径激活模式: （10 条路径的 1D 向量）。总共 1023 个子模型 (2^10 - 1)

返回类型:

arch_code_prob_a

get_ram_cost_usage(in_size, full=False)[source]#

获取估计的输出张量大小以近似内存开销。

参数:

in_size – 最高分辨率下的输入图像形状（4D/5D, [BCHW[D]]）。
full (bool) – 所有概率为 1 时的全内存开销使用情况。

get_topology_entropy(probs)[source]#

获取搜索阶段的拓扑熵损失。

参数:: probs – 路径激活概率

ComplexUnet#

class monai.apps.reconstruction.networks.nets.complex_unet.ComplexUnet(spatial_dims=2, features=(32, 32, 64, 128, 256, 32), act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv', pad_factor=16, conv_net=None)[source]#

此 U-Net 变体用于处理复数输入/输出。它可用作学习多线圈 MRI 数据中敏感度图的模型。默认构建于 monai.networks.nets.BasicUNet 之上，但用户也可以输入自己的卷积模型。ComplexUnet 还对输入应用默认归一化，使其训练更稳定。

使用此模型的前提是数据必须是（复数）2 通道张量。

修改并采用自: facebookresearch/fastMRI

参数:

spatial_dims (int) – 空间维度数量。
features (Sequence[int]) – 6 个整数，表示特征数量。指每一层中的通道数。
act (UnionType[str, tuple]) – 激活类型及参数。默认为 LeakyReLU。
norm (UnionType[str, tuple]) – 特征归一化类型及参数。默认为实例归一化。
bias (bool) – 卷积块中是否包含偏置项。默认为 True。
dropout (UnionType[float, tuple]) – dropout 比率。默认为 0.0。
upsample (str) – 上采样模式，可用选项包括 "deconv"、"pixelshuffle"、"nontrainable"。
pad_factor (int) – 一个整数，表示每个填充维度都应可被该数整除。例如，16 表示填充后每个维度都可以被 16 整除。
conv_net (Optional[Module, None]) – ComplexUnet 内部使用的学习模型。默认为 monai.networks.nets.basic_unet。对模型的唯一要求是输入和输出通道数为 2。

forward(x)[source]#

参数:: x (Tensor) – 2D 数据的形状为 (B,C,H,W,2) 或 3D 数据的形状为 (B,C,H,W,D,2) 的输入
返回类型:: Tensor
返回:: 2D 数据的形状为 (B,C,H,W,2) 或 3D 数据的形状为 (B,C,H,W,D,2) 的输出

CoilSensitivityModel#

class monai.apps.reconstruction.networks.nets.coil_sensitivity_model.CoilSensitivityModel(spatial_dims=2, features=(32, 32, 64, 128, 256, 32), act=('LeakyReLU', {'inplace': True, 'negative_slope': 0.1}), norm=('instance', {'affine': True}), bias=True, dropout=0.0, upsample='deconv', coil_dim=1, conv_net=None)[source]#

此类使用卷积模型来学习多线圈 MRI 重建的线圈敏感度图。卷积模型默认为 monai.apps.reconstruction.networks.nets.complex_unet，但也可以由用户指定。学习是在欠采样 k 空间中心（该区域是全采样的）进行的。

使用此模型的前提是数据必须是（复数）2 通道张量。

修改并采用自: facebookresearch/fastMRI

参数:

spatial_dims (int) – 空间维度数量。
features (Sequence[int]) – 6 个整数，表示特征数量。指每一层中的通道数。
act (UnionType[str, tuple]) – 激活类型及参数。默认为 LeakyReLU。
norm (UnionType[str, tuple]) – 特征归一化类型及参数。默认为实例归一化。
bias (bool) – 卷积块中是否包含偏置项。默认为 True。
dropout (UnionType[float, tuple]) – dropout 比率。默认为 0.0。
upsample (str) – 上采样模式，可用选项包括 "deconv"、"pixelshuffle"、"nontrainable"。
coil_dim (int) – 数据中的线圈维度
conv_net (Optional[Module, None]) – 用于估计线圈敏感度图的学习模型。默认为 monai.apps.reconstruction.networks.nets.complex_unet。对模型的唯一要求是输入和输出通道数为 2。

forward(masked_kspace, mask)[source]#

参数:

masked_kspace (Tensor) – 欠采样 k 空间（即输入测量值）。2D 数据形状为 (B,C,H,W,2)，3D 数据形状为 (B,C,H,W,D,2)。
mask (Tensor) – 欠采样掩码，2D 数据形状为 (1,1,1,W,1)，3D 数据形状为 (1,1,1,1,D,1)。

返回类型:

Tensor

返回:

预测的线圈敏感度图，2D 数据形状为 (B,C,H,W,2)，3D 数据形状为 (B,C,H,W,D,2)。

get_fully_sampled_region(mask)[source]#

提取 k 空间全采样部分的大小。注意，当 k 空间欠采样时，其中心部分是全采样的。这部分称为自动校准区域 (Auto Calibration Region, ACR)。ACR 用于计算敏感度图。

参数:

mask (Tensor) – 形状为 (…, S, 1) 的欠采样掩码，其中 S 表示采样维度

返回类型:

tuple[int, int]

返回:

包含以下内容的元组：

该区域的左索引
该区域的右索引

注意

假设掩码形状为 (1,1,20,1)。如果该函数返回 8,12 作为左和右: 索引，则意味着全采样的中心区域大小为 4，从 8 开始到 12 结束。

e2e-VarNet#

class monai.apps.reconstruction.networks.nets.varnet.VariationalNetworkModel(coil_sensitivity_model, refinement_model, num_cascades=12, spatial_dims=2)[source]#

基于 Sriram 等人的“End-to-end variational networks for accelerated MRI reconstruction”的端到端变分网络 (e2e-VarNet)。它包含多个级联，每个级联由细化 (refinement) 和数据一致性 (data consistency) 步骤组成。该网络接收欠采样的 k 空间数据并估计地面实况重建结果。

修改并采用自: facebookresearch/fastMRI

参数:

coil_sensitivity_model (Module) – 用于学习线圈敏感度图的卷积模型。示例如 monai.apps.reconstruction.networks.nets.coil_sensitivity_model.CoilSensitivityModel。
refinement_model (Module) – 用于 e2e-VarNet 细化步骤的卷积网络。示例如 monai.apps.reconstruction.networks.nets.complex_unet.ComplexUnet。
num_cascades (int) – 级联数量。每个级联是一个 monai.apps.reconstruction.networks.blocks.varnetblock.VarNetBlock，由细化和数据一致性步骤组成。
spatial_dims (int) – 空间维度数量。

forward(masked_kspace, mask)[source]#

参数:

masked_kspace (Tensor) – 欠采样 k 空间。它是 2D k 空间 (B,C,H,W,2)，最后一个维度为 2（实部/虚部），C 表示线圈维度。3D 数据形状为 (B,C,H,W,D,2)。
mask (Tensor) – 2D 数据的掩码形状为 (1,1,1,W,1)，3D 数据的掩码形状为 (1,1,1,1,D,1)。

返回类型:

Tensor

返回:

重建的图像，它是预测 k 空间傅里叶逆变换: 绝对值的平方和根 (rss)（注意 rss 将线圈图像组合成一张图像）。

DAF3D#

class monai.networks.nets.DAF3D(in_channels, out_channels, visual_output=False)[source]#

DAF3D 网络，基于“Deep Attentive Features for Prostate Segmentation in 3D Transrectal Ultrasound” <https://arxiv.org/pdf/1907.01743.pdf>。该网络由一个应用在 3D ResNet 特征图上的 3D 特征金字塔网络 (FPN) 组成，后跟一个自定义注意力模块和一个 ASPP 模块。在训练期间，监督信号由 FPN 的输出（四个单层特征，SLF）、注意力模块的输出（四个注意力特征）和最终预测组成。它们分别与地面实况进行比较，最终损失由所有个体损失的加权和组成（详见 DAF3D 教程）。此外，还有一种可能性是在验证模式下返回所有监督信号以及注意力图，以可视化网络的内部功能。

参数:

in_channels – 输入通道数。
out_channels – 输出通道数。
visual_output – 是否在验证模式下返回所有 SLF、注意力图、精细化 SLF，可用于可视化网络的内部功能。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

Quicknat#

class monai.networks.nets.Quicknat(num_classes=33, num_channels=1, num_filters=64, kernel_size=5, kernel_c=1, stride_conv=1, pool=2, stride_pool=2, se_block='None', drop_out=0, act='PRELU', norm='INSTANCE', adn_ordering='NA')[source]#

用于“Quick segmentation of NeuroAnaTomy (QuickNAT)”的模型，基于深度全卷积神经网络。参考：“QuickNAT: A Fully Convolutional Network for Quick and Accurate Segmentation of Neuroanatomy by Abhijit Guha Roya, Sailesh Conjetib, Nassir Navabb, Christian Wachingera”。

QuickNAT 具有类似于 2D F-CNN 的编码器/解码器架构，包含 4 个编码器和 4 个解码器，中间由瓶颈层分隔。最后一层是带有 softmax 的分类器块。该架构在所有相同空间分辨率的编码器和解码器块之间包含跳跃连接，类似于 U-Net 架构。所有编码器和解码器由三个卷积层组成，均带有批归一化 (Batch Normalization) 和 ReLU。前两个卷积层之后是连接层，将输入特征图与当前和前一个卷积块的输出连接起来。前两个卷积层的核大小为 5*5，第三个卷积层的核大小为 1*1。

编码路径中的数据使用最大池化层下采样（而不是像 UNet 那样），解码路径中使用最大反池化层 (max un-pooling) 上采样（而不是转置卷积）。池化在块的开头执行，反池化在块的结尾执行。编码器中最大池化的索引会通过层传递，以便对应的解码器使用。

瓶颈块由一个 5*5 卷积层和一个批归一化层组成，用于分隔网络的编码器和解码器部分，限制编码器和解码器之间的信息流。

最后一个解码器块的输出特征图被传递到分类器块，这是一个具有 1*1 核大小的卷积层，将输入映射到 N 通道特征图，其中 N 是分割类别数。

原始 QuickNAT 实现包含一种用于测试期间不确定性估计的 enable_test_dropout() 机制。由于 dropout 层是该网络中唯一的随机组件，在测试或推理时调用 train() 方法而不是 eval() 会产生相同的效果。

参数:

num_classes (int) – 要分割的类别数（输出通道数）。
num_channels (int) – 输入通道数。
num_filters (int) – 密集块 (Dense Block) 中每个卷积层的输出通道数。
kernel_size (UnionType[Sequence[int], int]) – 密集块中每个卷积层的核大小。
kernel_c (int) – 分类器块的卷积核大小。
stride_convolution – 卷积步长。默认为 1。
pool (int) – 池化层的核大小，
stride_pool (int) – 池化层的步长。
se_block (str) – 要包含的 Squeeze and Excite 块类型，默认为 None。有效选项：NONE, CSE, SSE, CSSE，
droup_out – dropout 比率。默认为无 dropout。
act (UnionType[tuple, str]) – 激活类型及参数。默认为 PReLU。
norm (UnionType[tuple, str]) – 特征归一化类型及参数。默认为实例归一化。
adn_ordering (str) – 表示激活 (A)、归一化 (N) 和 dropout (D) 顺序的字符串。默认为 “NA”。另请参阅：monai.networks.blocks.ADN。

示例

from monai.networks.nets import QuickNAT

# network with max pooling by a factor of 2 at each layer with no se_block.
net = QuickNAT(
    num_classes=3,
    num_channels=1,
    num_filters=64,
    pool = 2,
    se_block = "None"
)

forward(input)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

get_selayer(n_filters, se_block_type='None')[source]#

返回在 QuickNAT 模型初始化中定义的 SEBlock。

参数:

n_filters – 层的编码部分
se_block_type – 默认为 None。有效选项为 None, CSE, SSE, CSSE

返回：适当的 SEBlock。SSE 和 CSSE 尚未在 Monai 中实现。

property is_cuda#: 检查模型参数是否分配在 GPU 上。

VoxelMorph#

class monai.networks.nets.VoxelMorphUNet(spatial_dims, in_channels, unet_out_channels, channels, final_conv_channels, final_conv_act='LEAKYRELU', kernel_size=3, up_kernel_size=3, act='LEAKYRELU', norm=None, dropout=0.0, bias=True, use_maxpool=True, adn_ordering='NDA')[source]#

VoxelMorph 中使用的骨干网络。详情请参考 monai.networks.nets.VoxelMorph。

一对连接的图像（移动图像和固定图像）首先通过一个 UNet。UNet 的输出随后通过一系列卷积块，以产生位移场 (DDF) 或平稳速度场 (DVF) 的最终预测。

在原始实现中，下采样是通过最大池化实现的，这里可以选择使用最大池化或步长卷积进行下采样。默认使用最大池化，因为它与原始实现一致。注意，对于上采样，VoxelMorph 作者使用的是最近邻插值而不是转置卷积。在本实现中，仅支持最近邻插值以保持与原始实现一致。

该类的实例可用作构建 VoxelMorph 网络的骨干网络。有关如何构建 VoxelMorph 网络的更多详细信息和示例，请参阅 monai.networks.nets.VoxelMorph 的文档。

参数:

spatial_dims (int) – 空间维度数量。
in_channels (int) – 连接移动图像和固定图像后输入卷的通道数。
unet_out_channels (int) – UNet 输出的通道数。
channels (Sequence[int]) – UNet 每层的通道数。有关详细信息，请参阅以下示例。
final_conv_channels (Sequence[int]) – 最终卷积块每层的通道数。
final_conv_act (UnionType[tuple, str, None]) – 最终卷积块的激活类型。默认为 LeakyReLU。由于 VoxelMorph 最初是在 tensorflow 中实现的，其 LeakyReLU 的默认负斜率为 0.2，因此我们在这里使用相同的默认值。
kernel_size (UnionType[Sequence[int], int]) – UNet 中所有卷积层的核大小。默认为 3。
up_kernel_size (UnionType[Sequence[int], int]) – UNet 上采样路径中所有卷积层的核大小。默认为 3。
act (UnionType[tuple, str]) – UNet 中所有卷积层的激活类型。默认为负斜率为 0.2 的 LeakyReLU。
norm (Union[tuple, str, None]) – UNet 中所有卷积层的特征归一化类型和参数。默认为 None。
dropout (float) – UNet 中所有卷积层的 dropout 比率。默认为 0.0（无 dropout）。
bias (bool) – UNet 中所有卷积层是否使用偏置。默认为 True。
use_maxpool (bool) – UNet 下采样路径中是否使用最大池化。默认为 True。使用最大池化与 VoxelMorph 的原始实现一致。但可以选择使用步长卷积代替（即设置 use_maxpool 为 False）。
adn_ordering (str) – 激活、dropout 和归一化的顺序。默认为 “NDA”。

forward(concatenated_pairs)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

返回类型:: Tensor

class monai.networks.nets.VoxelMorph(backbone=None, integration_steps=7, half_res=False, spatial_dims=3)[source]#

医学图像配准 VoxelMorph 框架的重新实现，如 https://arxiv.org/pdf/1809.05231.pdf 所述。有关更多详细信息，请参考：VoxelMorph: A Learning Framework for Deformable Medical Image Registration, Guha Balakrishnan, Amy Zhao, Mert R. Sabuncu, John Guttag, Adrian V. Dalca IEEE TMI: Transactions on Medical Imaging. 2019. eprint arXiv:1809.05231。

此类旨在作为一个通用框架，在此基础上可以构建可变形图像配准网络。给定用户指定的骨干网络（例如，原始 VoxelMorph 论文中的 UNet），此类充当包装器，将输入的一对移动和固定图像连接起来，通过骨干网络，整合骨干网络预测的平稳速度场 (DVF) 以获得位移场 (DDF)，最后使用 DDF 对移动图像进行变形。

要构建 VoxelMorph 网络，首先需要构建一个骨干网络（例如 monai.networks.nets.VoxelMorphUNet）并将其传递给 monai.networks.nets.VoxelMorph 的构造函数。骨干网络应能够接收一对移动和固定图像作为输入，并产生 DVF（或 DDF，稍后讨论详细信息）作为输出。

当调用 forward 时，输入的移动图像和固定图像首先沿通道维度连接，并通过指定的骨干网络产生 DDF 的预测（在非微分同胚变体中，即当 integration_steps 设置为 0 时）或平稳速度场 DVF（在微分同胚变体中，即当 integration_steps 设置为正整数时）。然后，DVF 通过 monai.networks.blocks.warp.DVF2DDF 模块利用缩放平方 (scaling-and-squaring) 方法进行整合，以产生 DDF。最后，DDF 使用 monai.networks.blocks.warp.Warp 模块将移动图像变形到固定图像。可选地，通过将 half_res 设置为 True，可以在降低的分辨率下执行从 DVF 到 DDF 的整合，在这种情况下，来自骨干网络的输出 DVF 在整合前首先被线性插值到一半分辨率。输出 DDF 在用于变形移动图像之前再次线性插值回全分辨率。

参数:

backbone (Union[VoxelMorphUNet, Module, None]) – 骨干网络。
integration_steps (int) – 用于通过缩放平方从 DVF 获取 DDF 的整合步数。默认为 7。如果设置为 0，网络将是非微分同胚的。
half_res (bool) – 是否在半分辨率下执行整合。默认为 False。
spatial_dims (int) – 空间维度数，默认为 3。

示例

from monai.networks.nets import VoxelMorphUNet, VoxelMorph

# The following example construct an instance of VoxelMorph that matches the original VoxelMorph paper
# https://arxiv.org/pdf/1809.05231.pdf

# First, a backbone network is constructed. In this case, we use a VoxelMorphUNet as the backbone network.
backbone = VoxelMorphUNet(
    spatial_dims=3,
    in_channels=2,
    unet_out_channels=32,
    channels=(16, 32, 32, 32, 32, 32),  # this indicates the down block at the top takes 16 channels as
                                        # input, the corresponding up block at the top produces 32
                                        # channels as output, the second down block takes 32 channels as
                                        # input, and the corresponding up block at the same level
                                        # produces 32 channels as output, etc.
    final_conv_channels=(16, 16)
)

# Then, a full VoxelMorph network is constructed using the specified backbone network.
net = VoxelMorph(
    backbone=backbone,
    integration_steps=7,
    half_res=False
)

# A forward pass through the network would look something like this
moving = torch.randn(1, 1, 160, 192, 224)
fixed = torch.randn(1, 1, 160, 192, 224)
warped, ddf = net(moving, fixed)

forward(moving, fixed)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

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

实用工具#

用于定义网络的实用程序和类型，这些依赖于 PyTorch。

class monai.networks.utils.CastTempType(initial_type, temporary_type, submodule)[source]#

在应用子模块之前将输入张量转换为临时类型，然后再将其转回初始类型。

forward(x)[source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

monai.networks.utils.convert_to_onnx(model, inputs, input_names=None, output_names=None, opset_version=None, dynamic_axes=None, filename=None, verify=False, device=None, use_ort=False, ort_provider=None, rtol=0.0001, atol=0.0, use_trace=True, do_constant_folding=True, constant_size_threshold=17179869184, **kwargs)[source]#

用于将模型转换为 ONNX 模型并选择性地使用 ONNX 或 onnxruntime 进行验证的实用工具。请参阅 https://pytorch.ac.cn/docs/stable/onnx.html 了解如何将 PyTorch 模型转换为 ONNX。

参数:

model (Module) – 要保存的源 PyTorch 模型。
inputs (Sequence[Any]) – pytorch.onnx.export 使用的输入样本数据。它也用于 ONNX 模型验证。
input_names (Optional[Sequence[str], None]) – ONNX 模型的可选输入名称。
output_names (Optional[Sequence[str], None]) – ONNX 模型的可选输出名称。
opset_version (Optional[int, None]) – 目标 (ai.onnx) opset 版本。必须 >= 7 且不超过
PyTorch (支持的最新 opset 版本) – onnx/onnx 和 pytorch/pytorch
details (更多详情) – onnx/onnx 和 pytorch/pytorch
dynamic_axes (Union[Mapping[str, Mapping[int, str]], Mapping[str, Sequence[int]], None]) – 指定张量的哪些轴是动态的（即仅在运行时已知）。如果设置为 None，导出的模型将设置所有输入和输出张量的形状以匹配给定的形状，更多详情：https://pytorch.ac.cn/docs/stable/onnx.html#torch.onnx.export。
filename (Optional[Any, None]) – 保存 ONNX 模型的可选文件名，如果为 None，则不保存 ONNX 模型。
verify (bool) – 是否使用 ONNX 或 onnxruntime 验证 ONNX 模型。
device (Optional[device, None]) – 验证模型的目标 PyTorch 设备，如果为 None，则在可用时使用 CUDA。
use_ort (bool) – 是否使用 onnxruntime 来验证模型。
ort_provider – 要使用的 onnxruntime 提供程序，默认为 [“CPUExecutionProvider”。
rtol (float) – 比较 PyTorch 模型和 TorchScript 模型输出时的相对容差。
atol (float) – 比较 PyTorch 模型和 TorchScript 模型输出时的绝对容差。
use_trace (bool) – 是否使用 torch.jit.trace 导出 torchscript 模型。
do_constant_folding (bool) – 传递给 onnx.export()。如果为 True，则执行额外的 polygraphy 折叠通道。
constant_size_threshold (int) – 传递给 polygraphy 的常量折叠（constant folding），默认值 = 16M
kwargs – 如果 use_trace=True：传递给 torch.onnx.export() 的额外参数；否则：除 obj 外传递给 torch.jit.script() 以转换模型的其他参数，更多详情请参考： https://pytorch.ac.cn/docs/master/generated/torch.jit.script.html。

monai.networks.utils.convert_to_torchscript(model, filename_or_obj=None, extra_files=None, verify=False, inputs=None, device=None, rtol=0.0001, atol=0.0, use_trace=False, **kwargs)[source]#

用于将模型转换为 TorchScript 模型并保存到文件的实用工具，支持可选的输入/输出数据验证。

参数:

model (Module) – 要保存的源 PyTorch 模型。
filename_or_obj (Optional[Any, None]) – 如果不为 None，则指定一个类文件对象（必须实现 write 和 flush 方法）或包含文件路径名的字符串，用于保存 TorchScript 模型。
extra_files (Optional[dict, None]) – 文件名到内容的映射，这些内容将作为保存的模型文件的一部分存储。更多详情请参考： https://pytorch.ac.cn/docs/stable/generated/torch.jit.save.html。
verify (bool) – 是否验证 TorchScript 模型的输入和输出。如果 filename_or_obj 不为 None，则加载已保存的 TorchScript 模型并进行验证。
inputs (Optional[Sequence[Any], None]) – 用于验证模型的输入测试数据，应为一个数据序列，每一项对应 model() 函数的一个参数。
device (Optional[device, None]) – 用于验证模型的目标设备，如果为 None，则在可用时使用 CUDA。
rtol (float) – 比较 PyTorch 模型和 TorchScript 模型输出时的相对容差。
atol (float) – 比较 PyTorch 模型和 TorchScript 模型输出时的绝对容差。
use_trace (bool) – 是否使用 torch.jit.trace 来导出 TorchScript 模型。
kwargs – 除 obj 外传递给 torch.jit.script() 或 torch.jit.trace()（如果 use_trace 为 True）以转换模型的其他参数，更多详情请参考： https://pytorch.ac.cn/docs/master/generated/torch.jit.script.html。

monai.networks.utils.convert_to_trt(model, precision, input_shape, dynamic_batchsize=None, use_trace=False, filename_or_obj=None, verify=False, device=None, use_onnx=False, onnx_input_names=('input_0',), onnx_output_names=('output_0',), rtol=0.01, atol=0.0, **kwargs)[source]#

用于将模型导出为基于 TensorRT 引擎的 TorchScript 模型，并支持可选的输入/输出数据验证的实用工具。

导出模型有两种方式：1. Torch-TensorRT 方式：PyTorch 模块 -> TorchScript 模块 -> 基于 TensorRT 引擎的 TorchScript。2. ONNX-TensorRT 方式：PyTorch 模块 -> TorchScript 模块 -> ONNX 模型 -> TensorRT 引擎 -> 基于 TensorRT 引擎的 TorchScript。

通过第一种方式导出时，某些模型会遇到运行变慢的问题，因为 Torch-TensorRT 可能只能将 PyTorch 模型的一小部分转换为 TensorRT 引擎。然而，通过第二种方式导出时，不支持像 dict 这样的某些 Python 数据结构。并且，如果通过 torch.jit.script 导出，某些 TorchScript 模型不被 ONNX 支持。

参数:

model (Module) – 要转换的源 PyTorch 模型。
precision (str) – 转换后的基于 TensorRT 引擎的 TorchScript 模型的权重精度。应为 ‘fp32’ 或 ‘fp16’。
input_shape (Sequence[int]) – 用于转换模型的输入形状。应为像 [N, C, H, W] 或 [N, C, H, W, D] 这样的列表。
dynamic_batchsize (Optional[Sequence[int], None]) – 一个包含三个元素的序列，用于定义要转换模型输入的 batch size 范围。应为像 [MIN_BATCH, OPT_BATCH, MAX_BATCH] 这样的序列。转换后，模型输入的 batch size 应在 MIN_BATCH 和 MAX_BATCH 之间，OPT_BATCH 是 TensorRT 尝试拟合的最佳性能 batch size。OPT_BATCH 应为应用程序中最常使用的输入 batch size，默认为 None。
use_trace (bool) – 是否使用 torch.jit.trace 将 PyTorch 模型转换为 TorchScript 模型，然后转换为基于 TensorRT 引擎的 TorchScript 模型或 ONNX 模型（如果 use_onnx 为 True），默认为 False。
filename_or_obj (Optional[Any, None]) – 如果不为 None，则指定一个类文件对象（必须实现 write 和 flush 方法）或包含文件路径名的字符串，用于加载基于 TensorRT 引擎的 TorchScript 模型以进行验证。
verify (bool) – 是否验证基于 TensorRT 引擎的 TorchScript 模型的输入和输出。
device (Optional[int, None]) – 用于转换和验证模型的目标 GPU 索引。如果为 None，则使用 #0 号 GPU。
use_onnx (UnionType[bool, None]) – 是否使用 ONNX-TensorRT 方式来导出基于 TensorRT 引擎的 TorchScript 模型。
onnx_input_names (UnionType[Sequence[str], None]) – ONNX 模型的可选输入名称。此参数仅在 use_onnx 为 True 时有用。应为一个类似于 (‘input_0’, ‘input_1’, …, ‘input_N’) 的序列，其中 N 等于模型输入的数量。如果不提供，将使用 (‘input_0’,)，这假设模型只有一个输入。
onnx_output_names (UnionType[Sequence[str], None]) – ONNX 模型的可选输出名称。此参数仅在 use_onnx 为 True 时有用。应为一个类似于 (‘output_0’, ‘output_1’, …, ‘output_N’) 的序列，其中 N 等于模型输出的数量。如果不提供，将使用 (‘output_0’,)，这假设模型只有一个输出。
rtol (float) – 比较 PyTorch 模型和 TensorRT 模型输出时的相对容差。
atol (float) – 比较 PyTorch 模型和 TensorRT 模型输出时的绝对容差。
kwargs – 除 module, inputs, enabled_precisions 和 device 外传递给 torch_tensorrt.compile() 以编译模型的其他参数，更多详情请参考： https://pytorch.ac.cn/TensorRT/py_api/torch_tensorrt.html#torch-tensorrt-py。

monai.networks.utils.copy_model_state(dst, src, dst_prefix='', mapping=None, exclude_vars=None, inplace=True, filter_func=None)[source]#

计算一个模块的 state_dict，其键与 dst 相同。只要键匹配，dst 的值就会被 src 的值覆盖。该方法在匹配时为 dst 键提供了额外的 dst_prefix。mapping 可以是一个 {“src_key”: “dst_key”} 字典，表示 dst[dst_prefix + dst_key] = src[src_key]。此函数主要用于返回一个模型 state_dict，以便将 src 模型状态加载到 dst 模型中，src 和 dst 可以有不同的字典键，但它们对应的值通常具有相同的形状。

参数:

dst (UnionType[Module, Mapping]) – 要更新的 PyTorch 模块或 state dict。
src (UnionType[Module, Mapping]) – 用于获取更新值的 PyTorch 模块或 state dict。
dst_prefix – dst 键前缀，使得 dst[dst_prefix + src_key] 将被赋值为 src[src_key] 的值。
mapping – 一个 {“src_key”: “dst_key”} 字典，表示 dst[dst_prefix + dst_key] 将被赋值为 src[src_key] 的值。
exclude_vars – 一个正则表达式，用于匹配 dst 变量名，以便它们的值不会被 src 覆盖。
inplace – 是否通过 load_state_dict 使用更新后的 state_dict 设置 dst 模块。此选项仅在 dst 为 torch.nn.Module 时可用。
filter_func – 一个过滤函数，用于过滤要加载的权重。参见 “monai.networks.nets.swin_unetr.py” 中的 ‘filter_swinunetr’。

示例

from monai.networks.nets import BasicUNet
from monai.networks.utils import copy_model_state

model_a = BasicUNet(in_channels=1, out_channels=4)
model_b = BasicUNet(in_channels=1, out_channels=2)
model_a_b, changed, unchanged = copy_model_state(
    model_a, model_b, exclude_vars="conv_0.conv_0", inplace=False)
# dst model updated: 76 of 82 variables.
model_a.load_state_dict(model_a_b)
# <All keys matched successfully>

返回：一个包含更新后的 dst 状态、已更改键和未更改键的 OrderedDict。

monai.networks.utils.eval_mode(*nets)#

将网络设置为评估模式，并在结束时恢复原始状态。

参数:: nets (Module) – 输入网络

示例

t=torch.rand(1,1,16,16)
p=torch.nn.Conv2d(1,1,3)
print(p.training)  # True
with eval_mode(p):
    print(p.training)  # False
    print(p(t).sum().backward())  # will correctly raise an exception as gradients are calculated

monai.networks.utils.get_profile_shapes(input_shape, dynamic_batchsize)[source]#: 给定样本输入形状，根据 dynamic_batchsize 计算最小/优化/最大形状。

monai.networks.utils.get_state_dict(obj)[source]#

如果输入对象具有 state_dict，则获取其 state_dict，否则直接返回对象。对于数据并行（DataParallel）模型，会自动先将其转换为常规模型。

参数:: obj (UnionType[Module, Mapping]) – 用于检查并获取 state_dict 的输入对象。

monai.networks.utils.has_nvfuser_instance_norm()[source]#: 当前环境是否具有 InstanceNorm3dNVFuser NVIDIA/apex

monai.networks.utils.icnr_init(conv, upsample_factor, init=<function kaiming_normal_>)[source]#: ICNR 初始化，用于 2D/3D 核，改编自 Aitken 等人，2017 年，“Checkerboard artifact free sub-pixel convolution”。

monai.networks.utils.look_up_named_module(name, mod, print_all_options=False)[source]#

通过属性名获取 mod 中的命名模块，例如 look_up_named_module(net, "features.3.1.attn")

参数:

name (str) – 表示模块属性的字符串。
mod – 要搜索的 PyTorch 模块（在 mod.named_modules() 中）。
print_all_options – 当在 mod 中未找到 name 时，是否打印所有命名模块。默认为 False。

返回:

相应的 PyTorch 模块的子组件，例如 net.features[3][1].attn

monai.networks.utils.normal_init(m, std=0.02, normal_func=<function normal_>)[source]#

将 m 及其子模块的权重和偏置张量初始化为来自正态分布的值，标准差为 `std`。卷积和线性模块的权重张量初始化为均值 0，批归一化（batch norm）模块初始化为均值 1。用于分配值的可调用对象 `normal_func` 应具有与其默认的 normal_() 相同的参数。这可以与 `nn.Module.apply` 一起使用以访问网络的子模块。

返回类型:: None

monai.networks.utils.normalize_transform(shape, device=None, dtype=None, align_corners=False, zero_centered=False)[source]#

根据输入形状计算仿射矩阵。该转换将齐次图像坐标归一化到 [-1, 1] 的范围内。目前支持以下源坐标：

align_corners=False, zero_centered=False，从 [-0.5, d-0.5] 进行归一化。

align_corners=True, zero_centered=False，从 [0, d-1] 进行归一化。

align_corners=False, zero_centered=True，从 [-(d-1)/2, (d-1)/2] 进行归一化。

align_corners=True, zero_centered=True，从 [-d/2, d/2] 进行归一化。

参数:

shape – 输入空间形状，一个整数序列。
device (Union[str, device, None]) – 分配返回仿射矩阵的设备。
dtype (Optional[dtype, None]) – 返回仿射矩阵的数据类型。
align_corners (bool) – 如果为 True，则认为 -1 和 1 指的是角像素的中心，而不是图像的角。参见： https://pytorch.ac.cn/docs/stable/nn.functional.html#torch.nn.functional.grid_sample
zero_centered (bool) – 坐标是否从以零为中心的范围进行归一化，默认为 False。设置此标志和 align_corners 将共同指定归一化的源范围。

返回类型:

Tensor

monai.networks.utils.one_hot(labels, num_classes, dtype=torch.float32, dim=1)[source]#

对于 labels 中的每个值 v，输出中的值将为 1 或 0。dim 维度上的每个向量都具有“one-hot”格式，即它的总长度为 num_classes，包含一个 1 和 num_class-1 个 0。请注意，这包括背景标签，因此二值掩码应视为具有两个类别。

参数:

labels (Tensor) – 要转换为 ‘one-hot’ 格式的整数输入张量。内部会将 labels 转换为整数 labels.long()。
num_classes (int) – 输出通道数，labels[dim] 的相应长度将从 1 转换为 num_classes。
dtype (dtype) – 输出 one_hot 标签的数据类型。
dim (int) – 要从 1 通道转换为 num_classes 通道的维度，应为非负数。

示例

对于维数为 [B]1[spatial_dims] 的张量 labels，当 num_classes=N（类别数）且 dim=1 时，返回维数为 [B]N[spatial_dims] 的张量。

from monai.networks.utils import one_hot
import torch

a = torch.randint(0, 2, size=(1, 2, 2, 2))
out = one_hot(a, num_classes=2, dim=0)
print(out.shape)  # torch.Size([2, 2, 2, 2])

a = torch.randint(0, 2, size=(2, 1, 2, 2, 2))
out = one_hot(a, num_classes=2, dim=1)
print(out.shape)  # torch.Size([2, 2, 2, 2, 2])

返回类型:: Tensor

monai.networks.utils.pixelshuffle(x, spatial_dims, scale_factor)[source]#

对具有空间维度 spatial_dims 和缩放因子 scale_factor 的张量 x 应用像素洗牌（pixel shuffle）。

参考：Shi 等人，2016 年，“利用高效子像素卷积神经网络进行实时单图像和视频超分辨率”。

参考：Aitken 等人，2017 年，“无棋盘格伪影的子像素卷积”。

参数:

x (Tensor) – 形状为 BCHW[D] 的输入张量
spatial_dims (int) – 空间维度的数量，对于 2D 或 3D 通常为 2 或 3
scale_factor (int) – 重新缩放空间维度的因子，必须 >=1

返回类型:

Tensor

返回:

x 的重洗版本。

引发异常:

ValueError – 当 x 的输入通道不能被 (scale_factor ** spatial_dims) 整除时

monai.networks.utils.pixelunshuffle(x, spatial_dims, scale_factor)[source]#

对具有空间维度 spatial_dims 和缩放因子 scale_factor 的张量 x 应用像素逆洗牌（pixel unshuffle）。这是 pixelshuffle 的逆操作。

参考：Shi 等人，2016 年，“利用高效子像素卷积神经网络进行实时单图像和视频超分辨率”。

参考：Aitken 等人，2017 年，“无棋盘格伪影的子像素卷积”。

参数:

x (Tensor) – 形状为 BCHW[D] 的输入张量
spatial_dims (int) – 空间维度的数量，对于 2D 或 3D 通常为 2 或 3
scale_factor (int) – 减小空间维度的因子，必须 >=1

返回类型:

Tensor

返回:

x 的逆重洗版本，形状为 (B, C*(r**d), H/r, W/r)（针对 2D）或 (B, C*(r**d), D/r, H/r, W/r)（针对 3D），其中 r 是 scale_factor，d 是 spatial_dims。

引发异常:

ValueError – 当空间维度不能被 scale_factor 整除时

monai.networks.utils.predict_segmentation(logits, mutually_exclusive=False, threshold=0.0)[source]#

给定网络输出的 logits，计算分割：如果是多标签任务，通过对所有大于 0 的值进行阈值化计算；如果是多类别任务，则沿通道轴计算 argmax，logits 的形状为 BCHW[D]。

参数:

logits (Tensor) – 模型输出的原始数据。
mutually_exclusive (bool) – 如果为 True，logits 将使用 argmax 的组合转换为二值矩阵，这适用于多类别任务。默认为 False。
threshold (float) – 如果是多标签任务，对预测值进行阈值化。

返回类型:

Any

monai.networks.utils.replace_modules(parent, name, new_module, strict_match=True, match_device=True)[source]#

替换父模块中的子模块。

要替换的模块名称可以是嵌套的，例如 features.denseblock1.denselayer1.layers.relu1。如果是这种情况（模块名称中有“.”），则此函数将递归调用自身。

参数:

parent (Module) – 包含要替换模块的模块
name (str) – 要替换的模块名称。可以包含“.”。
new_module (Module) – 要放置在父模块中 name 位置的 torch.nn.Module。如果 strict_match == False，这将进行深度拷贝，多个实例是独立的。
strict_match (bool) – 如果 True，模块名称必须 == name。如果为 False，则将使用 name in named_modules()。 True 可用于仅更改一个模块，而 False 可用于替换所有具有相似名称的模块（例如 relu）。
match_device (bool) – 如果 True，新模块的设备将与模型匹配。要求 parent 的所有部分都在同一设备上。

返回类型:

list[tuple[str, Module]]

返回:

已替换模块的元组列表。元素 0 是模块名称，元素 1 是替换后的模块。

引发异常:

AttributeError – 如果 strict_match 为 True 且 name 在 parent 中不是命名模块。

monai.networks.utils.replace_modules_temp(parent, name, new_module, strict_match=True, match_device=True)#

暂时替换父模块中的子模块（上下文管理器）。

参见 monai.networks.utils.replace_modules。

monai.networks.utils.save_state(src, path, **kwargs)[source]#

使用 PyTorch save 保存输入源数据的 state dict。它可以保存 nn.Module、state_dict 或 nn.Module 或 state_dict 的字典。并自动将数据并行模块转换为常规模块。例如

save_state(net, path)
save_state(net.state_dict(), path)
save_state({"net": net, "opt": opt}, path)
net_dp = torch.nn.DataParallel(net)
save_state(net_dp, path)

参考： https://pytorch.ac.cn/ignite/v0.4.8/generated/ignite.handlers.DiskSaver.html。

参数:

src (UnionType[Module, dict]) – 要保存的输入数据，可以是 nn.Module、state_dict、nn.Module 或 state_dict 的字典。
path (UnionType[str, PathLike]) – 保存输入对象的目标文件路径。
kwargs – 除 obj 和 path 外用于 save_obj 的其他参数。默认 func 是 torch.save()，参数详情： https://pytorch.ac.cn/docs/stable/generated/torch.save.html。

monai.networks.utils.set_named_module(mod, name, new_layer)[source]#

查找 mod 中的 name 并将该层替换为 new_layer，返回更新后的 mod。

参数:

mod – 要更新的 PyTorch 模块。
name (str) – 表示目标模块属性的字符串。
new_layer – 替换 mod.name 处相应层的新模块。

返回:

更新后的 mod

参见： monai.networks.utils.look_up_named_module()。

monai.networks.utils.to_norm_affine(affine, src_size, dst_size, align_corners=False, zero_centered=False)[source]#

给定为像素空间坐标定义的 affine，计算归一化坐标对应的仿射变换。

参数:

affine (Tensor) – Nxdxd 批处理方阵
src_size (Sequence[int]) – 源图像空间形状
dst_size (Sequence[int]) – 目标图像空间形状
align_corners (bool) – 如果为 True，则认为 -1 和 1 指的是角像素的中心，而不是图像的角。参见： https://pytorch.ac.cn/docs/stable/nn.functional.html#torch.nn.functional.grid_sample
zero_centered (bool) – 坐标是否从以零为中心的范围进行归一化，默认为 False。参见： monai.networks.utils.normalize_transform()。

引发异常:

TypeError – 当 affine 不是 torch.Tensor 时。
ValueError – 当 affine 不是 Nxdxd 时。
ValueError – 当 src_size 或 dst_size 的维度与 affine 不同时。

返回类型:

Tensor

monai.networks.utils.train_mode(*nets)#

将网络设置为训练模式，并在结束时恢复原始状态。

参数:: nets (Module) – 输入网络

示例

t=torch.rand(1,1,16,16)
p=torch.nn.Conv2d(1,1,3)
p.eval()
print(p.training)  # False
with train_mode(p):
    print(p.training)  # True
    print(p(t).sum().backward())  # No exception

此脚本包含用于在 PyTorch 中开发新网络/块的实用函数。

monai.apps.reconstruction.networks.nets.utils.complex_normalize(x)[source]#

对复数数据执行层均值-标准差归一化。归一化针对每个 batch 成员沿每个部分（部分指实部和虚部）分别进行。

参数:

x (Tensor) – 2D 数据形状为 (B,C,H,W) 或 3D 数据形状为 (B,C,H,W,D) 的输入

返回类型:

tuple[Tensor, Tensor, Tensor]

返回:

包含以下内容的元组：

2D 数据形状为 (B,C,H,W) 或 3D 数据形状为 (B,C,H,W,D) 的归一化输出
均值
标准差

monai.apps.reconstruction.networks.nets.utils.divisible_pad_t(x, k=16)[source]#

填充输入以馈送到网络（兼容 Torch Script）

参数:

x (Tensor) – 2D 数据形状为 (B,C,H,W) 或 3D 数据形状为 (B,C,H,W,D) 的输入
k (int) – 填充因子。每个填充维度的长度都将能被 k 整除。

返回类型:

tuple[Tensor, tuple[tuple[int, int], tuple[int, int], tuple[int, int], int, int, int]]

返回:

包含以下内容的元组：

填充后的输入
填充尺寸（如果需要反向填充）

示例

import torch

# 2D data
x = torch.ones([3,2,50,70])
x_pad,padding_sizes = divisible_pad_t(x, k=16)
# the following line should print (3, 2, 64, 80)
print(x_pad.shape)

# 3D data
x = torch.ones([3,2,50,70,80])
x_pad,padding_sizes = divisible_pad_t(x, k=16)
# the following line should print (3, 2, 64, 80, 80)
print(x_pad.shape)

monai.apps.reconstruction.networks.nets.utils.floor_ceil(n)[source]#

返回输入的向下取整和向上取整值

参数:

n (float) – 输入数字

返回:

floor(n)
ceil(n)

返回类型:

包含以下内容的元组：

monai.apps.reconstruction.networks.nets.utils.inverse_divisible_pad_t(x, pad_sizes)[source]#

对网络输出进行反填充，以匹配其原始形状

参数:

x (Tensor) – 2D 数据形状为 (B,C,H,W) 或 3D 数据形状为 (B,C,H,W,D) 的输入
pad_sizes (tuple[tuple[int, int], tuple[int, int], tuple[int, int], int, int, int]) – 填充值

返回类型:

Tensor

返回:

反填充后的输入

monai.apps.reconstruction.networks.nets.utils.reshape_batch_channel_to_channel_dim(x, batch_size)[source]#

分离 batch 和通道维度。

参数:

x (Tensor) – 2D 数据形状为 (B*C,1,H,W,2) 或 3D 数据形状为 (B*C,1,H,W,D,2) 的输入
batch_size (int) – batch 大小

返回类型:

Tensor

返回:

输出形状为 (B,C,…)

monai.apps.reconstruction.networks.nets.utils.reshape_channel_complex_to_last_dim(x)[source]#

交换复数维度和通道维度，使网络输出的最后一个维度为 2

参数:: x (Tensor) – 2D 数据形状为 (B,C*2,H,W) 或 3D 数据形状为 (B,C*2,H,W,D) 的输入
返回类型:: Tensor
返回:: 2D 数据的形状为 (B,C,H,W,2) 或 3D 数据的形状为 (B,C,H,W,D,2) 的输出

monai.apps.reconstruction.networks.nets.utils.reshape_channel_to_batch_dim(x)[source]#

合并 batch 和通道维度。

参数:

x (Tensor) – 2D 数据的形状为 (B,C,H,W,2) 或 3D 数据的形状为 (B,C,H,W,D,2) 的输入

返回:

输出形状为 (B*C,1,…)
batch 大小

返回类型:

包含以下内容的元组：

monai.apps.reconstruction.networks.nets.utils.reshape_complex_to_channel_dim(x)[source]#

交换复数维度和通道维度，使网络将实部/虚部视为两个独立的通道。

参数:: x (Tensor) – 2D 数据的形状为 (B,C,H,W,2) 或 3D 数据的形状为 (B,C,H,W,D,2) 的输入
返回类型:: Tensor
返回:: 输出 2D 数据形状为 (B,C*2,H,W) 或 3D 数据形状为 (B,C*2,H,W,D) 的形状

monai.apps.reconstruction.networks.nets.utils.sensitivity_map_expand(img, sens_maps, spatial_dims=2)[source]#

根据给定的 sens_maps 将图像扩展为其相应的线圈图像。假设有 C 个线圈。此函数将图像 img 与 sens_maps 中的每个线圈灵敏度图相乘，并将生成的 C 个线圈图像沿线圈专用通道维度进行堆叠。

参数:

img (Tensor) – 2D 图像 (B,1,H,W,2)，最后一个维度为 2（表示实部/虚部）。3D 数据的形状为 (B,1,H,W,D,2)。
sens_maps (Tensor) – 用于组合线圈图像的灵敏度图。对于 2D 数据，形状为 (B,C,H,W,2)，对于 3D 数据，形状为 (B,C,H,W,D,2)（C 表示线圈维度）。
spatial_dims (int) – 2D 数据为 2，3D 数据为 3

返回类型:

Tensor

返回:

x 扩展为 2D 数据的 (B,C,H,W,2) 和 3D 数据的 (B,C,H,W,D,2)。输出被传输: 到频域以产生线圈测量值。

monai.apps.reconstruction.networks.nets.utils.sensitivity_map_reduce(kspace, sens_maps, spatial_dims=2)[source]#

根据给定的 sens_maps 将线圈测量值还原为相应的图像。假设 kspace 内有 C 个线圈测量值，则此函数将每个线圈灵敏度图的共轭与相应的线圈图像相乘。此过程的结果将是 C 个图像。将这些图像相加得到最终的“还原图像”。

参数:

kspace (Tensor) – 2D kspace (B,C,H,W,2)，最后一个维度为 2（表示实部/虚部），C 表示线圈维度。3D 数据形状为 (B,C,H,W,D,2)。
sens_maps (Tensor) – 与输入 x 形状相同的灵敏度图。
spatial_dims (int) – 2D 数据为 2，3D 数据为 3

返回类型:

Tensor

返回:

2D 数据还原为 (B,1,H,W,2) 或 3D 数据还原为 (B,1,H,W,D,2)。

噪声调度器（Noise Schedulers）#

Scheduler#

class monai.networks.schedulers.Scheduler(num_train_timesteps=1000, schedule='linear_beta', **schedule_args)[source]#

基于噪声调度函数的其他调度器的基类。

此类旨在作为其他调度器的基类，这些调度器实现了自己的采样或步进方式。在此，该类根据名为 schedule 的噪声调度函数（它是 NoiseSchedules 中的组件名称）定义 beta、alpha 和 alpha_cumprod 值。这些组件必须都是可调用的，返回单独的 beta 调度或包含 (betas, alphas, alphas_cumprod) 值的元组。可以使用 NoiseSchedules.add_def 提供新的调度函数，例如

from monai.networks.schedulers import NoiseSchedules, DDPMScheduler

@NoiseSchedules.add_def("my_beta_schedule", "Some description of your function")
def _beta_function(num_train_timesteps, beta_start=1e-4, beta_end=2e-2):
    return torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)

scheduler = DDPMScheduler(num_train_timesteps=1000, schedule="my_beta_schedule")

所有此类函数都应具有一个初始位置整数参数 num_train_timesteps，说明调度的时间步数，否则可以给出任何其他参数，这些参数将通过构造函数的 schedule_args 值按关键字传递。要查看可用的噪声函数，请打印 NoiseSchedules 对象以获取存储对象的列表及其文档字符串描述。

注意：在调度器的早期版本中，使用参数 schedule_beta 来声明 beta 调度类型，现在已将其替换为 schedule，大多数以前使用的名称现在都附加了 “_beta”，例如 ‘schedule_beta=”linear”’ -> ‘schedule=”linear_beta”’。beta_start 和 beta_end 参数仍用于某些调度，但现在作为关键字参数提供。

参数:

num_train_timesteps (int) – 用于训练模型的扩散步数。
schedule (str) – NoiseSchedules 的成员，一个返回 beta 张量或 (betas, alphas, alphas_cumprod) 三元组的命名函数
schedule_args – 传递给调度函数的参数

add_noise(original_samples, noise, timesteps)[source]#

向原始样本添加噪声。

参数:

original_samples (Tensor) – 原始样本
noise (Tensor) – 要添加到样本中的噪声
timesteps (Tensor) – 指示每个样本要计算的时间步的时间步张量。

返回:

添加了噪声的样本

返回类型:

noisy_samples

NoiseSchedules#

monai.networks.schedulers.NoiseSchedules#
<monai.utils.component_store.ComponentStore object> 的别名

DDPMScheduler#

class monai.networks.schedulers.DDPMScheduler(num_train_timesteps=1000, schedule='linear_beta', variance_type=fixed_small, clip_sample=True, prediction_type=epsilon, clip_sample_min=-1.0, clip_sample_max=1.0, schedule_args)[source]#
去噪扩散概率模型（DDPMs）探索了去噪评分匹配与 Langevin 动力学采样之间的联系。基于：Ho 等人，“Denoising Diffusion Probabilistic Models” https://arxiv.org/abs/2006.11239

参数:

num_train_timesteps (`int`) – 用于训练模型的扩散步数。

schedule (`str`) – NoiseSchedules 的成员，组件存储中噪声调度函数的名称

variance_type (`str`) – DDPMVarianceType 的成员

clip_sample (`bool`) – 将预测样本剪切在 -1 和 1 之间以实现数值稳定性的选项。

prediction_type (`str`) – DDPMPredictionType 的成员

clip_sample_min (`float`) – clip_sample 为 True 时的最小剪切值

clip_sample_max (`float`) – clip_sample 为 True 时的最大剪切值

schedule_args** – 传递给调度函数的参数

set_timesteps(num_inference_steps, device=None)[source]#
设置用于扩散链的离散时间步。这是推理前要运行的支撑函数。

参数:

num_inference_steps (`int`) – 使用预训练模型生成样本时使用的扩散步数。

device (`Union`[`str`, `device`, `None`]) – 放置数据的目标设备。

返回类型:

`None`

step(model_output, timestep, sample, generator=None)[source]#
通过反转 SDE 来预测前一个时间步的样本。这是根据学习到的模型输出（通常是预测的噪声）传播扩散过程的核心函数。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

generator (`Optional`[`Generator`, `None`]) – 随机数生成器。

返回:

预测的前一个样本

返回类型:

pred_prev_sample

DDIMScheduler#

class monai.networks.schedulers.DDIMScheduler(num_train_timesteps=1000, schedule='linear_beta', clip_sample=True, set_alpha_to_one=True, steps_offset=0, prediction_type=epsilon, clip_sample_min=-1.0, clip_sample_max=1.0, schedule_args)[source]#
去噪扩散隐式模型（DDIM）是一个调度器，它通过非马尔可夫引导扩展了去噪扩散概率模型（DDPMs）中引入的去噪过程。基于：Song 等人，“Denoising Diffusion Implicit Models” https://arxiv.org/abs/2010.02502

参数:

num_train_timesteps (`int`) – 用于训练模型的扩散步数。

schedule (`str`) – NoiseSchedules 的成员，组件存储中噪声调度函数的名称

clip_sample (`bool`) – 将预测样本剪切在 -1 和 1 之间以实现数值稳定性的选项。

set_alpha_to_one (`bool`) – 每个扩散步都使用该步和前一步的 alphas 乘积值。对于最后一步，没有前一个 alpha。当此选项为 True 时，前一个 alpha 乘积固定为 1，否则使用 step 0 的 alpha 值。

steps_offset (`int`) – 添加到推理步数的偏移量。你可以使用 steps_offset=1 和 set_alpha_to_one=False 的组合，使最后一步为前一个 alpha 乘积使用 step 0，正如在稳定扩散（stable diffusion）中所做的那样。

prediction_type (`str`) – DDPMPredictionType 的成员

clip_sample_min (`float`) – clip_sample 为 True 时的最小剪切值

clip_sample_max (`float`) – clip_sample 为 True 时的最大剪切值

schedule_args** – 传递给调度函数的参数

reversed_step(model_output, timestep, sample)[source]#
通过反转 SDE 来预测下一个时间步的样本。这是根据学习到的模型输出（通常是预测的噪声）传播扩散过程的核心函数。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

返回:

预测的前一个样本 pred_original_sample：预测的原始样本

返回类型:

pred_prev_sample

set_timesteps(num_inference_steps, device=None)[source]#
设置用于扩散链的离散时间步。这是推理前要运行的支撑函数。

参数:

num_inference_steps (`int`) – 使用预训练模型生成样本时使用的扩散步数。

device (`Union`[`str`, `device`, `None`]) – 放置数据的目标设备。

返回类型:

`None`

step(model_output, timestep, sample, eta=0.0, generator=None)[source]#
通过反转 SDE 来预测前一个时间步的样本。这是根据学习到的模型输出（通常是预测的噪声）传播扩散过程的核心函数。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

eta (`float`) – 扩散步中添加噪声的权重。

generator (`Optional`[`Generator`, `None`]) – 随机数生成器。

返回:

预测的前一个样本 pred_original_sample：预测的原始样本

返回类型:

pred_prev_sample

PNDMScheduler#

class monai.networks.schedulers.PNDMScheduler(num_train_timesteps=1000, schedule='linear_beta', skip_prk_steps=False, set_alpha_to_one=False, prediction_type=epsilon, steps_offset=0, schedule_args)[source]#
扩散模型的伪数值方法（PNDM）建议使用更先进的 ODE 积分技术，即龙格-库塔法（Runge-Kutta method）和线性多步法。基于：Liu 等人，“Pseudo Numerical Methods for Diffusion Models on Manifolds” https://arxiv.org/abs/2202.09778

参数:

num_train_timesteps (`int`) – 用于训练模型的扩散步数。

schedule (`str`) – NoiseSchedules 的成员，组件存储中噪声调度函数的名称

skip_prk_steps (`bool`) – 允许调度器跳过原论文中定义为在 plms 步之前必需的龙格-库塔步。

set_alpha_to_one (`bool`) – 每个扩散步都使用该步和前一步的 alphas 乘积值。对于最后一步，没有前一个 alpha。当此选项为 True 时，前一个 alpha 乘积固定为 1，否则使用 step 0 的 alpha 值。

prediction_type (`str`) – DDPMPredictionType 的成员

steps_offset (`int`) – 添加到推理步数的偏移量。你可以使用 offset=1 和 set_alpha_to_one=False 的组合，使最后一步为前一个 alpha 乘积使用 step 0，正如在稳定扩散（stable diffusion）中所做的那样。

schedule_args** – 传递给调度函数的参数

set_timesteps(num_inference_steps, device=None)[source]#
设置用于扩散链的离散时间步。这是推理前要运行的支撑函数。

参数:

num_inference_steps (`int`) – 使用预训练模型生成样本时使用的扩散步数。

device (`Union`[`str`, `device`, `None`]) – 放置数据的目标设备。

返回类型:

`None`

step(model_output, timestep, sample)[源码]#

通过反转随机微分方程（SDE）来预测前一时间步的样本。这是从学习到的模型输出（通常为预测的噪声）传播扩散过程的核心函数。该函数会根据内部变量 counter 调用 step_prk() 或 step_plms()。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

返回:

预测的前一个样本

返回类型:

pred_prev_sample

step_plms(model_output, timestep, sample)[源码]#

使用线性多步法传播样本的步进函数。该方法通过一次前向传递及多次运算来近似求解。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

返回:

预测的前一个样本

返回类型:

pred_prev_sample

step_prk(model_output, timestep, sample)[源码]#

使用龙格-库塔（Runge-Kutta）法传播样本的步进函数。RK 法通过 4 次前向传递来近似求解微分方程。

参数:

model_output (`Tensor`) – 来自学习到的扩散模型的直接输出。

timestep (`int`) – 扩散链中的当前离散时间步。

sample (`Tensor`) – 扩散过程当前正在创建的样本实例。

返回:

预测的前一个样本

返回类型:

pred_prev_sample

RFlowScheduler#

class monai.networks.schedulers.RFlowScheduler(num_train_timesteps=1000, use_discrete_timesteps=True, sample_method='uniform', loc=0.0, scale=1.0, use_timestep_transform=False, transform_scale=1.0, steps_offset=0, base_img_size_numel=32768, spatial_dim=3)[源码]#

一种用于指导生成模型中扩散过程的修正流（rectified flow）调度器。

支持均匀采样和 logit-normal 采样方法、针对不同分辨率的时间步转换，以及扩散过程中的噪声添加。

参数:

num_train_timesteps (int) – 训练时间步总数。
use_discrete_timesteps (bool) – 是否使用离散时间步。
sample_method (str) – 训练时间步采样方法（'uniform' 或 'logit-normal'）。
loc (float) – Logit-normal 分布的位置参数，仅在 sample_method='logit-normal' 时使用。
scale (float) – Logit-normal 分布的尺度参数，仅在 sample_method='logit-normal' 时使用。
use_timestep_transform (bool) – 是否应用时间步转换。若为真，对于较大的图像体积，在早期（噪声较大的）阶段将会有更多的推理时间步。
transform_scale (float) – 时间步转换的缩放因子，仅在 use_timestep_transform=True 时使用。
steps_offset (int) – 添加到计算出的时间步的偏移量，仅在 use_timestep_transform=True 时使用。
base_img_size_numel (int) – 用于缩放的参考图像体积大小，仅在 use_timestep_transform=True 时使用。
spatial_dim (int) – 2 或 3，表示 2D 或 3D 图像，仅在 use_timestep_transform=True 时使用。

示例

# define a scheduler
noise_scheduler = RFlowScheduler(
    num_train_timesteps = 1000,
    use_discrete_timesteps = True,
    sample_method = 'logit-normal',
    use_timestep_transform = True,
    base_img_size_numel = 32 * 32 * 32,
    spatial_dim = 3
)

# during training
inputs = torch.ones(2,4,64,64,32)
noise = torch.randn_like(inputs)
timesteps = noise_scheduler.sample_timesteps(inputs)
noisy_inputs = noise_scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
predicted_velocity = diffusion_unet(
    x=noisy_inputs,
    timesteps=timesteps
)
loss = loss_l1(predicted_velocity, (inputs - noise))

# during inference
noisy_inputs = torch.randn(2,4,64,64,32)
input_img_size_numel = torch.prod(torch.tensor(noisy_inputs.shape[-3:])
noise_scheduler.set_timesteps(
    num_inference_steps=30, input_img_size_numel=input_img_size_numel)
)
all_next_timesteps = torch.cat(
    (noise_scheduler.timesteps[1:], torch.tensor([0], dtype=noise_scheduler.timesteps.dtype))
)
for t, next_t in tqdm(
    zip(noise_scheduler.timesteps, all_next_timesteps),
    total=min(len(noise_scheduler.timesteps), len(all_next_timesteps)),
):
    predicted_velocity = diffusion_unet(
        x=noisy_inputs,
        timesteps=timesteps
    )
    noisy_inputs, _ = noise_scheduler.step(predicted_velocity, t, noisy_inputs, next_t)
final_output = noisy_inputs

add_noise(original_samples, noise, timesteps)[源码]#

向原始样本添加噪声。

参数:

original_samples (Tensor) – 原始样本
noise (Tensor) – 要添加到样本中的噪声
timesteps (Tensor) – 形状为 (N,) 的时间步张量，指示每个样本要计算的时间步。

返回:

添加了噪声的样本

返回类型:

noisy_samples

sample_timesteps(x_start)[源码]#

使用选定的采样方法随机采样训练时间步。

参数:: x_start (torch.Tensor) – 用于采样的输入张量。
返回:: 采样得到的时间步。
返回类型:: torch.Tensor

set_timesteps(num_inference_steps, device=None, input_img_size_numel=None)[源码]#

设置用于扩散链的离散时间步。这是推理前要运行的支撑函数。

参数:

num_inference_steps (int) – 使用预训练模型生成样本时使用的扩散步数。
device (Union[str, device, None]) – 放置数据的目标设备。
input_img_size_numel (Optional[int, None]) – int，图像的 H*W*D，当 self.use_timestep_transform 为 True 时使用。

返回类型:

None

step(model_output, timestep, sample, next_timestep=None)[源码]#

预测扩散过程中的下一个样本。

参数:

model_output (torch.Tensor) – 训练好的扩散模型的输出。
timestep (int) – 扩散链中的当前时间步。
sample (torch.Tensor) – 过程中的当前样本。
next_timestep (Union[int, None]) – 可选的下一个时间步。

返回:

下一时间步的预测样本及附加信息。

返回类型:

tuple[torch.Tensor, torch.Tensor]

网络架构#

模块#

ADN#

Convolution#

CRF#

ResidualUnit#

Swish#

MemoryEfficientSwish#

FPN#

Mish#

GEGLU#

GCN 模块#

细化模块#

FCN 模块#

多通道 FCN 模块#

Dynamic-Unet 模块#

DenseBlock#

SegResnet 模块#

SABlock 模块#

CABlock 模块#

前馈模块#

Squeeze-and-Excitation（通道挤压与激励）#

Transformer 模块#

UNETR 模块#

残差 Squeeze-and-Excitation（通道挤压与激励）#

Squeeze-and-Excitation（通道挤压与激励）模块#

Squeeze-and-Excitation 瓶颈（Bottleneck）#

Squeeze-and-Excitation Resnet 瓶颈#

Squeeze-and-Excitation ResNeXt 瓶颈#

简单 ASPP#

最大-平均池化#

上采样#

下采样 (Downsampling)#

注册残差卷积块 (Registration Residual Conv Block)#

注册下采样块 (Registration Down Sample Block)#

注册提取块 (Registration Extraction Block)#

LocalNet 下采样块 (LocalNet DownSample Block)#

LocalNet 上采样块 (LocalNet UpSample Block)#

LocalNet 特征提取块 (LocalNet Feature Extractor Block)#

MLP 块 (MLP Block)#

Patch 嵌入块 (Patch Embedding Block)#

因子化增加块 (FactorizedIncreaseBlock)#

因子化减少块 (FactorizedReduceBlock)#

P3DActiConvNormBlock#

ActiConvNormBlock#

Warp#

DVF2DDF#

VarNetBlock#

N 维傅里叶变换#

层#

工厂 (Factories)#

split_args#

Dropout#

Act#

Norm#

Conv#

Pad#

Pool#

ChannelPad#

SkipConnection#

Flatten#

Reshape#

separable_filtering#

apply_filter#

GaussianFilter#

MedianFilter#

median_filter#

BilateralFilter#

TrainableBilateralFilter#

TrainableJointBilateralFilter#

PHLFilter#

GaussianMixtureModel#

SavitzkyGolayFilter#

HilbertTransform#

Affine Transform#

grid_pull#

grid_push#

grid_count#

grid_grad#

LLTM#