网络架构#

块#

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)、Dropout (D) 和归一化 (N) 层的顺序模块，顺序任意

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

参数:

ordering – 表示激活、Dropout 和归一化顺序的字符串。默认为“NDA”。
in_channels – 预期输入尺寸 (N, C, H[, W, D]) 中的 C。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
norm_dim – 确定归一化层的空间维度。如果未指定，则默认为 dropout_dim。
dropout – Dropout 率。默认为不使用 Dropout。
dropout_dim –
确定 Dropout 的空间维度。如果未指定，则默认为 norm_dim。
- 当 dropout_dim = 1 时，随机将每个通道中的一些元素置零。
- 当 dropout_dim = 2 时，随机将整个通道置零（一个通道是一个二维特征图）。
- 当 dropout_dim = 3 时，随机将整个通道置零（一个通道是一个三维特征图）。

示例

# 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]#

构建一个包含归一化、可选 Dropout 和可选激活层的卷积

-- (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 – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
strides – 卷积步长。默认为 1。
kernel_size – 卷积核大小。默认为 3。
adn_ordering – 表示激活、归一化和 Dropout 顺序的字符串。默认为“NDA”。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
dropout – Dropout 率。默认为不使用 Dropout。
dropout_dim –
确定 Dropout 的空间维度。默认为 1。
- 当 dropout_dim = 1 时，随机将每个通道中的一些元素置零。
- 当 dropout_dim = 2 时，随机将整个通道置零（一个通道是一个二维特征图）。
- 当 dropout_dim = 3 时，随机将整个通道置零（一个通道是一个三维特征图）。
dropout_dim 的值不应大于 spatial_dims 的值。
dilation – 膨胀率。默认为 1。
groups – 控制输入和输出之间的连接。默认为 1。
bias – 是否包含偏置项。默认为 True。
conv_only – 是否只使用卷积层。默认为 False。
is_transposed – 如果为 True，则使用 ConvTrans 而不是 Conv。默认为 False。
padding – 控制对每个维度的 padding 数量点进行隐式零填充的数量。默认为 None。
output_padding – 控制添加到输出形状一侧的额外大小。默认为 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]#

条件随机场（Conditional Random Field）：将消息传递与类别兼容性卷积相结合，形成一个迭代过程，旨在逐步最小化类别标签的能量。

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

参阅: 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 – 迭代次数。
bilateral_weight – 消息传递步骤中双边项的权重。
gaussian_weight – 消息传递步骤中高斯项的权重。
bilateral_spatial_sigma – 双边项在空间坐标中的标准差。
bilateral_color_sigma – 双边项在色彩空间中的标准差。
gaussian_spatial_sigma – 高斯项在空间坐标中的标准差。
update_factor – 确定每次更新的幅度。
compatibility_matrix – 描述类别兼容性的矩阵，应为 NxN 矩阵，其中 N 是类别数量。

forward(input_tensor, reference_tensor)[source]#

参数:

input_tensor (Tensor) – 包含初始类别对数（logits）的张量。
reference_tensor (Tensor) – 用于引导消息传递的参考张量。

返回:

输出张量。

返回类型:

output (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 – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
strides – 卷积步长。默认为 1。
kernel_size – 卷积核大小。默认为 3。
subunits – 卷积数量。默认为 2。
adn_ordering – 表示激活、归一化和 Dropout 顺序的字符串。默认为“NDA”。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
dropout – Dropout 率。默认为不使用 Dropout。
dropout_dim –
确定 Dropout 的维度。默认为 1。
- 当 dropout_dim = 1 时，随机将每个通道中的一些元素置零。
- 当 dropout_dim = 2 时，随机将整个通道置零（一个通道是一个二维特征图）。
- 当 dropout_dim = 3 时，随机将整个通道置零（一个通道是一个三维特征图）。
dropout_dim 的值不应大于 dimensions 的值。
dilation – 膨胀率。默认为 1。
bias – 是否包含偏置项。默认为 True。
last_conv_only – 对于最后一个子单元，是否只使用卷积层。默认为 False。
padding – 控制对每个维度的 padding 数量点进行隐式零填充的数量。默认为 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{for constant value}~ \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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

MemoryEfficientSwish#

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

应用逐元素函数

\[\text{Swish}(x) = x * \text{Sigmoid}(\alpha * x) ~~~~\text{for constant value}~ \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+ 开始，实现了 Swish 的优化版本 SiLU，如果满足版本要求，此类将利用 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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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 – 二维或三维图像
in_channels_list – 传递给模块的每个特征图的通道数量
out_channels – FPN 表示的通道数量
extra_blocks – 如果提供，将执行额外的操作。预期它将 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 – 主干网络
return_layers – 一个字典，其键是需要返回激活的模块名称，其值是返回激活的名称（用户可以指定）。
in_channels_list – 返回的每个特征图的通道数量，按其在 OrderedDict 中出现的顺序排列
out_channels – FPN 中的通道数量。
spatial_dims – 二维或三维图像

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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

GEGLU#

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

应用逐元素函数

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

其中 \(x_1\) 和 \(x_2\) 沿最后一个维度从输入张量中分割而来。

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

形状

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

forward(input)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

GCN 模块#

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

使用大型一维 Kx1 和 1xK 核来表示二维核的全局卷积网络模块。

__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 个输入通道的二维 FCN 网络。小型解码器由 GCN 和 Refine 模块构建。代码改编自 lsqshr 的官方二维代码。

参数:

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]#

二维 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)。

动态 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: 基于 U-Net 的医学图像分割自适应框架 (nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation)。

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。
stride – 卷积步长。
norm_name – 特征归一化类型和参数。
act_name – 激活层类型和参数。
dropout – Dropout 概率。

forward(inp)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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: 基于 U-Net 的医学图像分割自适应框架 (nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation)。

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。
stride – 卷积步长。
norm_name – 特征归一化类型和参数。
act_name – 激活层类型和参数。
dropout – Dropout 概率。

forward(inp)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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: 基于 U-Net 的医学图像分割自适应框架 (nnU-Net: Self-adapting Framework for U-Net-Based Medical Image Segmentation)。

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。
stride – 卷积步长。
upsample_kernel_size – 转置卷积层的卷积核大小。
norm_name – 特征归一化类型和参数。
act_name – 激活层类型和参数。
dropout – Dropout 概率。
trans_bias – 转置卷积偏置。

forward(inp, skip)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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

forward(inp)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

DenseBlock#

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

DenseBlock 是一系列层，其中每层的输出都与其输入进行拼接。这具有将前一层输出累积为后续层输入以及作为块最终输出的效果。

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

SegResnet 块#

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

ResBlock 采用跳跃连接和两个卷积块，在 SegResNet 中使用，基于使用自编码器正则化的三维 MRI 脑肿瘤分割 (3D MRI brain tumor segmentation using autoencoder regularization)。

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

参数:

spatial_dims – 空间维度数量，可以是 1、2 或 3。
in_channels – 输入通道数量。
norm – 特征归一化类型和参数。
kernel_size – 卷积核大小，值应为奇数。默认为 3。
act – 激活类型和参数。默认为 RELU。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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 – 是否使用因果注意力 (参见 https://arxiv.org/abs/1706.03762)。
sequence_length – 如果 causal 为 True，则需要指定序列长度。
rel_pos_embedding (str, optional) – 向注意力图添加相对位置编码。目前仅支持“分解式”（参见 https://arxiv.org/abs/2112.01526）。支持 2D 和 3D。
input_size (tuple(spatial_dim), optional) – 输入分辨率，用于计算相对位置参数大小。
attention_dtype – 将注意力操作转换为此数据类型。
include_fc – 是否包含最终线性层。默认为 True。
use_combined_linear – qkv 投影是否使用单个线性层，默认为 True。
use_flash_attention – 如果为 True，使用 Pytorch 内建的 Flash Attention 以实现内存高效的注意力机制 (参见 https://pytorch.ac.cn/docs/2.2/generated/torch.nn.functional.scaled_dot_product_attention.html)。

forward(x)[source]#

参数:: x (torch.Tensor) – 输入张量。B x (s_dim_1 * … * s_dim_n) x C
返回:: B x (s_dim_1 * … * s_dim_n) x C
返回类型:: torch.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 et al., 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 – 空间维度数量，可以是 1、2 或 3。
in_channels – 输入通道数量。
r – 论文中的缩减比例 r。默认为 2。
acti_type_1 – 隐藏 Squeeze 层的激活类型。默认为 ("relu", {"inplace": True})。
acti_type_2 – 输出 Squeeze 层的激活类型。默认为“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 et al., 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。
use_flash_attention – 如果为 True，使用 Pytorch 内建的 Flash Attention 以实现内存高效的注意力机制 (参见 https://pytorch.ac.cn/docs/2.2/generated/torch.nn.functional.scaled_dot_product_attention.html)。
include_fc – 是否包含最终线性层。默认为 True。
use_combined_linear – qkv 投影是否使用单个线性层，默认为 True。

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

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 et al., 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 – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。
stride – 卷积步长。
norm_name – 特征归一化类型和参数。
res_block – 布尔参数，用于确定是否使用残差块。

forward(inp)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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

可用于 UNETR 的上采样模块：“Hatamizadeh et al., 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 – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。
upsample_kernel_size – 转置卷积层的卷积核大小。
norm_name – 特征归一化类型和参数。
res_block – 布尔参数，用于确定是否使用残差块。

forward(inp, skip)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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 et al., 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 – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
num_layer – 上采样块的数量。
kernel_size – 卷积核大小。
stride – 卷积步长。
upsample_kernel_size – 转置卷积层的卷积核大小。
norm_name – 特征归一化类型和参数。
conv_block – 布尔参数，用于确定是否使用卷积块。
res_block – 布尔参数，用于确定是否使用残差块。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

残差挤压和激励#

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

一个带有残差连接的“挤压和激励”式层

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

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

参数:

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

另请参阅

monai.networks.blocks.ChannelSELayer

挤压和激励模块#

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]#

通过挤压和激励增强的残差模块

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

基于 Hu et al., Squeeze-and-Excitation Networks, https://arxiv.org/abs/1709.01507” 的 SE-Resnet 块的重新实现。

__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 – 空间维度数量，可以是 1、2 或 3。
in_channels – 输入通道数量。
n_chns_1 – 第一个卷积的输出通道数。
n_chns_2 – 第二个卷积的输出通道数。
n_chns_3 – 第三个卷积的输出通道数。
conv_param_1 – 第一个卷积的附加参数。默认为 {"kernel_size": 1, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}
conv_param_2 – 第二个卷积的附加参数。默认为 {"kernel_size": 3, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}
conv_param_3 – 第三个卷积的附加参数。默认为 {"kernel_size": 1, "norm": Norm.BATCH, "act": None}
project – 如果残差通道数和输出通道数不匹配，则使用 project (Conv) 层/块来调整通道数。在 SENET 中，它由一个 Conv 层和一个 Norm 层组成。默认为 None（通道数匹配）或一个核大小为 1 的 Conv 层。
r – 论文中的缩减比例 r。默认为 2。
acti_type_1 – 隐藏挤压层的激活类型。默认为“relu”。
acti_type_2 – 输出 Squeeze 层的激活类型。默认为“sigmoid”。
acti_type_final – 块末尾的激活类型。默认为“relu”。

另请参阅

monai.networks.blocks.ChannelSELayer

forward(x)[source]#

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

挤压和激励瓶颈模块#

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

挤压和激励 Resnet 瓶颈模块#

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

挤压和激励 ResNeXt 瓶颈模块#

class monai.networks.blocks.SEResNeXtBottleneck(spatial_dims, inplanes, planes, groups, reduction, stride=1, downsample=None, base_width=4)[source]#: 带有挤压和激励模块的 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]#

空洞空间金字塔池化 (ASPP) 模块的简化版本。

Chen et al., Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation. https://arxiv.org/abs/1802.02611

Wang et al., 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 – 空间维度数量，可以是 1、2 或 3。
in_channels – 输入通道数量。
conv_out_channels – 每个空洞卷积的输出通道数。最终输出通道数为 conv_out_channels * len(kernel_sizes)。
kernel_sizes – 由四个卷积核大小组成的序列。默认为 (1, 3, 3, 3)，用于四个（空洞）卷积。
dilations – 由四个卷积空洞参数组成的序列。默认为 (1, 2, 4, 6)，用于四个（空洞）卷积。
norm_type – 最终核大小为一的卷积的归一化类型。默认为批量归一化。
acti_type – 最终核大小为一的卷积的激活类型。默认为 Leaky ReLU。
bias – 卷积块中是否包含偏置项。默认为 False。根据 Performance Tuning Guide，如果一个卷积层紧随一个批量归一化层，则偏置项应为 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 – 输入图像的空间维度数。
kernel_size – 两个池化操作的核大小。
stride – 窗口的步幅。默认值为 kernel_size。
padding – 添加到两个池化操作的隐式零填充。
ceil_mode – 如果为 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 – 输入图像的空间维度数。
in_channels – 输入图像的通道数。
out_channels – 输出图像的通道数。默认为 in_channels。
scale_factor – 空间大小的乘数。如果为元组，则必须与输入大小匹配。默认为 2。
kernel_size – 转置卷积期间使用的核大小。默认为 scale_factor。
size – 输出图像的空间大小。仅在 mode 为 UpsampleMode.NONTRAINABLE 时使用。在 torch.nn.functional.interpolate 中，只能定义 size 或 scale_factor 中的一个，因此如果定义了 size，则 scale_factor 将不被使用。默认为 None。
mode – {"deconv", "deconvgroup", "nontrainable", "pixelshuffle"}。默认为 "deconv"。
pre_conv – 上采样前应用的卷积块。默认为“default”。当 conv_block 为 "default" 时，仅在“nontrainable”或“pixelshuffle”模式下会使用一个保留的卷积层。
post_conv – 上采样后应用的卷积块。默认为 None。仅在“nontrainable”模式下使用。
interp_mode – {"nearest", "linear", "bilinear", "bicubic", "trilinear"} 仅在“nontrainable”模式下使用。如果以 "linear" 结尾，将根据 spatial dims 确定正确的插值方法。这分别对应于 1D、2D 和 3D 的线性、双线性和三线性插值。插值模式。默认为 "linear"。另请参阅：https://pytorch.ac.cn/docs/stable/generated/torch.nn.Upsample.html
align_corners – 设置 torch.nn.Upsample 的 align_corners 参数。默认为 True。仅在“nontrainable”模式下使用。
bias – 默认 preconv 和 deconv 层中是否包含偏置项。默认为 True。
apply_pad_pool – 如果为 True，则上采样张量会进行填充，然后应用核大小为 scale_factor、步幅为 1 的平均池化。另请参阅：monai.networks.blocks.SubpixelUpsample。仅在“pixelshuffle”模式下使用。

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)[source]#

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

参阅：Shi et al., 2016, “Real-Time Single Image and Video Super-Resolution Using a nEfficient Sub-Pixel Convolutional Neural Network.”

参阅：Aitken et al., 2017, “Checkerboard artifact free sub-pixel convolution”.

该想法来自：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)[source]#

参数:

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

forward(x)[source]#

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

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

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

配准残差卷积模块#

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

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

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

参数:

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

forward(x)[source]#

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

配准下采样模块#

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

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

改编自: DeepReg (DeepRegNet/DeepReg)

__init__(spatial_dims, channels, pooling)[source]#

参数:

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

forward(x)[source]#

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

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

配准特征提取模块#

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

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

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

参数:

spatial_dims – 空间维度数
extract_levels – 要提取特征的空间级别，0 表示输入尺度
num_channels – 每个尺度级别的通道数，列表或元组，长度等于 RegNet 的 depth
out_channels – 输出通道数
kernel_initializer – 核初始化器
activation – 核激活函数
mode – 特征图插值模式，默认为“nearest”。
align_corners – 是否对特征图插值进行角对齐。

forward(x, image_size)[source]#

参数:

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

返回类型:

Tensor

返回:

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

LocalNet 下采样模块#

class monai.networks.blocks.LocalNetDownSampleBlock(spatial_dims, in_channels, out_channels, kernel_size)[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, out_channels, kernel_size)[source]#

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
kernel_size – 卷积核大小。

引发:

NotImplementedError – 当 kernel_size 为偶数时。

forward(x)[source]#

将空间维度减半。返回一个元组 (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 上采样模块#

class monai.networks.blocks.LocalNetUpSampleBlock(spatial_dims, in_channels, out_channels, 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, out_channels, mode='nearest', align_corners=None)[source]#

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
mode – 加性上采样的插值模式，默认为“nearest”。
align_corners – 是否对加性上采样进行角对齐，默认为 None。

引发:

ValueError – 当 in_channels != 2 * out_channels 时。

forward(x, mid)[source]#

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

参数:

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 特征提取模块#

class monai.networks.blocks.LocalNetFeatureExtractorBlock(spatial_dims, in_channels, out_channels, act='RELU', initializer='kaiming_uniform')[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, out_channels, act='RELU', initializer='kaiming_uniform')[source]#: 参数： spatial_dims：空间维度数。 in_channels：输入通道数。 out_channels：输出通道数。 act：激活类型和参数。默认为 ReLU。 kernel_initializer：核初始化器。默认为 None。

forward(x)[source]#

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

MLP 模块#

class monai.networks.blocks.MLPBlock(hidden_size, mlp_dim, dropout_rate=0.0, act='GELU', dropout_mode='vit')[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, mlp_dim, dropout_rate=0.0, act='GELU', dropout_mode='vit')[source]#

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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)[source]#

一个基于以下研究的 Patch Embedding 块：“Dosovitskiy et al., An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <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)[source]#

参数:

in_channels – 输入通道的维度。
img_size – 输入图像的维度。
patch_size – Patch 大小的维度。
hidden_size – 隐藏层维度。
num_heads – 注意力头的数量。
proj_type – Patch Embedding 层类型。
pos_embed_type – 位置 Embedding 层类型。
dropout_rate – 输入单元的丢弃比例。
spatial_dims – 空间维度数量。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

FactorizedIncreaseBlock#

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

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

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

参数:

in_channel – 输入通道数
out_channel – 输出通道数
spatial_dims – 空间维度数
act_name – 激活层类型和参数。
norm_name – 特征归一化类型和参数。

FactorizedReduceBlock#

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

使用步长为 2 对特征进行下采样。沿每个空间维度的长度必须是 2 的倍数。

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

参数:

in_channel – 输入通道数
out_channel – 输出通道数。
spatial_dims – 空间维度数量。
act_name – 激活层类型和参数。
norm_name – 特征归一化类型和参数。

forward(x)[source]#

沿每个空间维度的长度必须是 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}))[source]#

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

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

参数:

in_channel – 输入通道数。
out_channel – 输出通道数。
kernel_size – 要扩展到 3D 的核大小。
padding – 要扩展到 3D 的填充大小。
mode –
各向异性核的模式
- 0: (k, k, 1), (1, 1, k),
- 1: (k, 1, k), (1, k, 1),
- 2: (1, k, k). (k, 1, 1)。
act_name – 激活层类型和参数。
norm_name – 特征归一化类型和参数。

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}))[source]#

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

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

参数:

in_channel – 输入通道数。
out_channel – 输出通道数。
kernel_size – 卷积核大小。
padding – 卷积填充大小。
spatial_dims – 空间维度数量。
act_name – 激活层类型和参数。
norm_name – 特征归一化类型和参数。

Warp#

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

使用给定的密集位移场（DDF）对图像进行形变。

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

对于原生 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 和 F. Pernus。基于互信息的分层弹性配准方法。Image and Vision Computing, 19:33-44, 2001。

forward(image, ddf)[source]#

参数:

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

返回:

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

DVF2DDF#

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

该层通过缩放和平方计算由密集速度场（DVF）得出的密集位移场（DDF）。

改编自: DeepReg (DeepRegNet/DeepReg)

forward(dvf)[source]#

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

VarNetBlock#

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

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

修改并采用自：facebookresearch/fastMRI

参数:

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

forward(current_kspace, ref_kspace, mask, sens_maps)[source]#

参数:

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)[source]#

对输入 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) – 原始欠采样 k-空间，形状与 x 相同。
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)[source]#

基于 Pytorch 的 spatial_dims 维信号的傅里叶变换 (fft)。"centered" 意味着此函数会自动处理所需的 ifft 和 fft 移位。这等价于在 numpy 中基于 numpy.fft.fftn, numpy.fft.fftshift, 和 numpy.fft.ifftshift 进行 ifft。

参数:

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

返回类型:

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)[source]#

基于 Pytorch 的 spatial_dims 维信号的逆傅里叶变换 (ifft)。"centered" 意味着此函数会自动处理所需的 ifft 和 fft 移位。这等价于在 numpy 中基于 numpy.fft.ifftn, numpy.fft.fftshift, 和 numpy.fft.ifftshift 进行 fft。

参数:

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

返回类型:

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)[source]#

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

参数:

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

返回类型:

Tensor

返回:

x 的移位版本

注意

当正在运行的 pytorch 版本中 fftshift 和 ifftshift 不可用时，调用此函数

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

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

参数:

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

返回类型:

Tensor

返回:

x 的 1D 移位版本

注意

当正在运行的 pytorch 版本中 fftshift 和 ifftshift 不可用时，调用此函数

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

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

参数:

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

返回类型:

Tensor

返回:

x 的 fft 移位版本

注意

当正在运行的 pytorch 版本中 fftshift 不可用时，调用此函数

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

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

参数:

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

返回类型:

Tensor

返回:

x 的 ifft 移位版本

注意

当正在运行的 pytorch 版本中 ifftshift 不可用时，调用此函数

层#

Factories#

定义工厂，用于以通用、可扩展和独立于维度的方式创建层。每种类型的层都会创建一个单独的工厂对象，然后将以名称为键的工厂函数添加到这些对象中。当请求一个层时，工厂名称和任何必要的参数都会传递给工厂对象。返回值通常是类型，但可以是生成层对象的任何可调用对象。

工厂对象包含以大写名称为键的函数，这些名称可以作为工厂的成员引用，以便它们充当常量标识符。例如，实例归一化命名为 Norm.INSTANCE。

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

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

这允许在构造函数中设置 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)[source]#

创建层的工厂对象，它使用给定的工厂函数实际生成类型或构造可调用对象。这些函数通过名称引用，可以随时添加。

add_factory_callable(name, func, desc=None)[source]#: 将工厂函数添加到此对象，名称为给定名称，可选择提供描述。

add_factory_class(name, cls, desc=None)[source]#: 添加一个工厂函数，该函数返回提供的类，名称为给定名称，可选择提供描述。

factory_function(name)[source]#

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

返回类型:: 可调用

get_constructor(factory_name, *args)[source]#

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

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

split_args#

monai.networks.layers.split_args(args)[source]#

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

参数:: args (str or a tuple of object name and kwarg dict) – 要解析的输入参数。
引发:: 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 层”：用于创建 Dropout 层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

支持的成员包括： dropout, alphadropout

Act#

层工厂“激活层”：用于创建激活层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

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

Norm#

层工厂“归一化层”：用于创建归一化层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

支持的成员包括： instance, batch, instance_nvfuser, group, layer, localresponse, syncbatch

Conv#

层工厂“卷积层”：用于创建卷积层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

支持的成员包括： conv, convtrans

Pad#

层工厂“填充层”：用于创建填充层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

支持的成员包括： replicationpad, constantpad

Pool#

层工厂“池化层”：用于创建池化层的工厂。有关其他参数解析，请参阅 monai.networks.layers.split_args。

支持的成员包括： max, adaptivemax, avg, adaptiveavg

ChannelPad#

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

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

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

参数:

spatial_dims – 输入图像的空间维度数。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
mode –
{"pad", "project"} 指定如何处理残差分支和卷积分支的通道不匹配。默认为 "pad"。
- "pad": 用零填充。
- "project": 用一个可训练的核大小为一的卷积层。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

SkipConnection#

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

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

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

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

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

参数:

submodule – 定义可训练分支的模块。
dim – 张量连接的维度。当 mode 为 "cat" 时使用。
mode – "cat", "add", "mul"。默认为 "cat"。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

Flatten#

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

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

Reshape#

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

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

__init__(*shape)[source]#

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

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

separable_filtering#

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

沿 x 的每个空间维度应用一维卷积。

参数:

x (Tensor) – 输入图像。形状必须为 (batch, channels, H[, W, …])。
kernels (list[Tensor]) – 沿每个空间维度的核。可以是一个单独的核（用于所有空间维度），或者一个包含 spatial_dims 个核的列表。
mode (string, optional) – 传递给卷积类的填充模式。 '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)[source]#

分别独立地对每个批次和通道使用 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)[source]#

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

参数:

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

forward(x)[source]#

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

MedianFilter#

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

对图像应用中值滤波。

参数:: radius – 模糊核半径（当 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)[source]#

参数:

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)[source]#

对图像应用中值滤波。

参数:

in_tensor – 输入张量；中值滤波将应用于最后 spatial_dims 个维度。
kernel_size – 卷积核大小。
spatial_dims – 应用中值滤波的空间维度数量。
kernel – 可选的自定义核。
kwargs – 传递给 conv 的附加参数。

返回:

过滤后的输入张量，形状与 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)[source]#

对输入张量进行空间模糊，同时保留边缘。可以在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) – 此标志选择两种实现之一。在某些情况下，近似方法可能会产生伪影，而精确解对于高空间标准差可能非常慢，无法忍受。

返回:

输出张量。

返回类型:

output (torch.Tensor)

static backward(ctx, grad_output)[source]#: 自动梯度反向传播

static forward(ctx, input, spatial_sigma=5, color_sigma=0.5, fast_approx=True)[source]#: 自动梯度前向传播

TrainableBilateralFilter#

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

实现了相应出版物中提出的可训练双边滤波器层。所有滤波器参数都可以通过数据驱动进行训练。空间滤波器核 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 – 强度范围核的可训练标准差。此滤波器参数决定边缘保留的程度。

返回:

过滤后的张量。

返回类型:

output (torch.Tensor)

forward(input_tensor)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

TrainableJointBilateralFilter#

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

实现了相应出版物中提出的可训练联合双边滤波器层。在过滤过程中，引导图像用作附加（边缘）信息。所有滤波器参数和引导图像都可以通过数据驱动进行训练。空间滤波器核 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 – 强度范围核的可训练标准差。此滤波器参数决定边缘保留的程度。

返回:

过滤后的张量。

返回类型:

output (torch.Tensor)

forward(input_tensor, guidance_tensor)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

PHLFilter#

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

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

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

参数:

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

返回:

输出张量。

返回类型:

output (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'。
返回:: 使用 Savitzky-Golay 核（窗口长度为 self.window_length，使用阶数为 self.order 的多项式）沿 self.axis 指定的轴过滤后的 x。
返回类型:: torch.Tensor

HilbertTransform#

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

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

参数:

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

forward(x)[source]#

参数:: x (Tensor) – 待变换的张量或类数组。必须是实数，形状为 [Batch, chns, spatial1, spatial2, ...]。
返回:: 沿 self.axis 指定的轴使用大小为 self.N 的 FFT 变换后的 x 的解析信号。 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) 输入 matrix，在齐次坐标上操作。另请参见： 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 – 输出空间形状，完整的输出形状将是 [N, C, *spatial_size]，其中 N 和 C 是从 self.forward 的 src 输入中推断出来的。
normalized – 指示提供的仿射矩阵 theta 是否是为标准化坐标定义的。如果 normalized=False，theta 将被转换为在标准化坐标上操作，因为 pytorch 的 affine_grid 使用标准化坐标。
mode – {"bilinear", "nearest"} 插值模式，用于计算输出值。默认为 "bilinear"。另请参见： https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html
padding_mode – {"zeros", "border", "reflection"} 网格外值的填充模式。默认为 "zeros"。另请参见： https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html
align_corners – 另请参见 https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.grid_sample.html。
reverse_indexing – 是否反转图像和坐标的空间索引。如果 theta 遵循 pytorch 默认的“D, H, W”约定，则设置为 False。如果 theta 遵循 scipy.ndimage 默认的“i, j, k”约定，则设置为 True。
zero_centered – 仿射变换是否应用于零中心值范围内的坐标。例如，如果 zero_centered=True，旋转中心将是输入的空间中心；如果 zero_centered=False，旋转中心将是输入的原点。此选项仅在 normalized=False 时可用，此时如果未指定，默认行为为 False。另请参见： monai.networks.utils.normalize_transform()。

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

theta 必须是一个仿射变换矩阵，形状为 3x3 或 Nx3x3 或 Nx2x3 或 2x3（用于空间 2D 变换），形状为 4x4 或 Nx4x4 或 Nx3x4 或 3x4（用于空间 3D 变换），其中 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 – 输出空间形状，完整的输出形状将是 [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 – 当仿射和图像的批量维度不同时。

grid_pull#

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

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

interpolation 可以是一个整数、字符串或 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 可以是一个整数、字符串或 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)。

返回类型:

output (torch.Tensor)

grid_push#

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

根据形变场对图像进行涂抹（拉取伴随）。

interpolation 可以是一个整数、字符串或 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 可以是一个整数、字符串或 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)。

返回类型:

output (torch.Tensor)

grid_count#

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

根据形变场（拉取伴随）进行权重涂抹。

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

interpolation 可以是一个整数、字符串或 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 可以是一个整数、字符串或 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)。

返回类型:

output (torch.Tensor)

grid_grad#

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

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

interpolation 可以是一个整数、字符串或 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 可以是一个整数、字符串或 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)。

返回类型:

output (torch.Tensor)

LLTM#

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

这个循环单元类似于 LSTM，但不同之处在于它没有遗忘门，并使用 Exponential Linear Unit (ELU) 作为其内部激活函数。由于此单元永远不会遗忘，故称为 LLTM，即长-长期记忆单元。它具有 C++ 和 CUDA 实现，会根据模块放置的目标设备自动切换。

参数:

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

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

forward(input, state)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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]#

运行 CG 迭代 num_iter 次以求解 Ax = y。

参数:

x (Tensor) – 张量（实数或复数）；线性系统 Ax = y 的初始猜测。
的大小应适用于线性算子。
例如
如果线性算子是
FFT，那么 x 的形状是 HCHW；如果
线性算子是矩阵
乘法，那么 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 的卷积时，输出张量的形状。所有参数可以是标量或多个值，如果所有输入都是标量，则返回值为标量。

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 对应于基于修正贝塞尔函数的 https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel。
normalize (bool) – 是否使用 kernel.sum() 对核进行归一化。

引发:

ValueError – 当 truncated 为非正数时。

返回类型:

Tensor

返回:

一维 torch 张量

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

在 x 处计算由 coef 定义的多项式的值。

对于一维系数序列（长度 n），计算

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

参数:

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

返回类型:

Tensor

返回:

一维 torch 张量

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

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

引发:: NotImplementedError – 当 np.any((kernel_size - 1) * dilation % 2 == 1) 时。

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 – 激活类型字符串或包含类型字符串和参数的元组。

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 – dropout 比率或包含 dropout 类型和参数的元组。
dropout_dim – 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 – 归一化类型字符串或包含类型字符串和参数的元组。
spatial_dims – 输入的空间维度数。
channels – 当归一化层需要此参数但在归一化参数中未指定时，特征/通道的数量。

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

创建一个池化层实例。

例如，创建自适应平均池化层：

from monai.networks.layers import get_pool_layer

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

参数:

name – 池化类型字符串或包含类型字符串和参数的元组。
spatial_dims – 输入的空间维度数。

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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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 – 输入图像的空间维度数。
in_channels – 输入通道的数量。
out_channels – 输出类别的数量。
init_features – 第一个卷积层中的滤波器数量。
growth_rate – 每层增加的滤波器数量（论文中的 k）。
block_config – 每个池化块中的层数。
bn_size – 瓶颈层数量的乘法因子。（即瓶颈层中的特征数量为 bn_size * k）
act – 激活类型和参数。默认为 relu。
norm – 特征归一化类型和参数。默认为批量归一化。
dropout_prob – 每个密集层之后的 dropout 率。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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]#: DenseNet121，当 spatial_dims 为 2 时支持可选的预训练。

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]#: DenseNet169，当 spatial_dims 为 2 时支持可选的预训练。

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]#: DenseNet201，当 spatial_dims 为 2 时支持可选的预训练。

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]#

EfficientNet 基于 Rethinking Model Scaling for Convolutional Neural Networks。改编自 EfficientNet-PyTorch。

参数:

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

forward(inputs)[source]#

参数:

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

返回:

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

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]#

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 – 要初始化的模型的名称，可以是 [efficientnet-b0, …, efficientnet-b8, efficientnet-l2] 中的一个。
pretrained – 是否初始化预训练的 ImageNet 权重，仅当 spatial_dims=2 且使用批量归一化时可用。
progress – 是否显示预训练权重下载的进度。
spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
num_classes – 输出类别的数量。
norm – 特征归一化类型和参数。
adv_prop – 是否使用对抗样本训练的权重。此参数仅在 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 模型作为骨干网络，骨干网络可用作分割和目标模型的编码器。与类 EfficientNetBN 相比，唯一的不同之处是 forward 函数。

此类参考 PyTorch 图像模型。

forward(inputs)[source]#

参数:

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

返回:

torch 张量的列表。

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]#

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

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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]#

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

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Union[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 – 输入数据的空间维度。默认为 3。
init_filters – 初始卷积层的输出通道数。默认为 32。
in_channels – 网络的输入通道数。默认为 1。
out_channels – 网络的输出通道数。默认为 2。
act – 激活类型和参数。默认为 RELU。
norm – 特征归一化类型和参数。默认为 BATCH。
blocks_down – 每层下采样块的数量。默认为 [1,2,2,4]。
blocks_up – 上采样块的数量（可选）。
dsdepth – 深度监督的层数。这将是每个比例级别输出列表的长度。在 dsdepth==1 时，只返回一个输出。
preprocess – 在模型前向传播之前应用的可选可调用函数。
resolution – 可选的输入图像分辨率。提供时，网络将首先使用非各向同性核将图像间距调整为近似各向同性空间。否则，默认情况下，核大小和下采样始终是各向同性的。

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

参数:

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

返回类型:

tuple[Union[None, Tensor, list[Tensor]], Union[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]#

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

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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 – 要使用的 ResNet 块，可以是 Basic 或 Bottleneck。ResNet 块类或字符串。对于 Basic：ResNetBlock 或 ‘basic’；对于 Bottleneck：ResNetBottleneck 或 ‘bottleneck’
layers – 要使用的层数。
block_inplanes – 确定每个步骤的通道数。也可以通过 widen_factor 进行调整。
spatial_dims – 输入图像的空间维度数。
n_input_channels – 第一个卷积层的输入通道数。
conv1_t_size – 第一个卷积层的大小，确定核和填充。
conv1_t_stride – 第一个卷积层的步幅。
no_max_pool – 布尔参数，确定是否使用最大池化层。
shortcut_type – 要使用的下采样块。选项为 ‘A’，‘B’，默认为 ‘B’。- ‘A’：使用 self._downsample_basic_block。- ‘B’：核大小为 1 的卷积 + 归一化。
widen_factor – 加宽每层的输出。
num_classes – 输出（分类）的数量。
feed_forward – 是否添加 FC 层作为输出，默认为 True。
bias_downsample – 在 shortcut_type 为 ‘B’ 时，是否在下采样块中使用偏置项，默认为 True。
act – 激活类型和参数。默认为 relu。
norm – 特征归一化类型和参数。默认为批量归一化。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 张量的列表。

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]#

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

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

SENet154#

class monai.networks.nets.SENet154(layers=(3, 8, 36, 3), groups=64, reduction=16, pretrained=False, progress=True, **kwargs)[source]#: SENet154 基于 Squeeze-and-Excitation Networks，在 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]#: SEResNet50 基于 Squeeze-and-Excitation Networks，在 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]#: SEResNet101 基于 Squeeze-and-Excitation Networks，在 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]#: SEResNet152 基于 Squeeze-and-Excitation Networks，在 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]#: SEResNext50 基于 Squeeze-and-Excitation Networks，在 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]#: SEResNext101 基于 Squeeze-and-Excitation Networks，在 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]#

highres3dnet 的重新实现，基于 Li 等人，“On the compactness, efficiency, and representation of 3D convolutional networks: Brain parcellation as a pretext task”, IPMI ‘17

改编自： NifTK/NiftyNet fepegar/highresnet

参数:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[source]#

参数:

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

引发:

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

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[source]#

动态 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。

医学图像分割十项全能数据集的使用示例可在以下位置找到：Project-MONAI/tutorials。

参数:

spatial_dims (int) – 空间维度数。
in_channels (int) – 输入通道数。
out_channels (int) – 输出通道数。
kernel_size (Sequence[Union[Sequence[int], int]]) – 卷积核尺寸。
strides (Sequence[Union[Sequence[int], int]]) – 每个块的卷积步长。
upsample_kernel_size (Sequence[Union[Sequence[int], int]]) – 转置卷积层的卷积核尺寸。该值应等于 strides[1:]。
filters (Optional[Sequence[int]]) – 每个块的输出通道数。与 nnU-Net 不同，此实现中添加此参数以使网络更灵活。如第三个参考文献所示，确定此参数的一种方法是：[64, 96, 128, 192, 256, 384, 512, 768, 1024][: len(strides)]。上述方法用于赢得 BraTS21 Challenge 任务 1 的网络。如果未指定，将采用 nnUNet 使用的方法。默认为 None。
dropout (Union[Tuple, str, float, None]) – dropout 比率。默认为无 dropout。
norm_name (Union[Tuple, str]) – 特征归一化类型和参数。默认为 INSTANCE。INSTANCE_NVFUSER 是实例归一化层的更快版本，可在以下情况使用：1) spatial_dims=3，2) CUDA 设备可用，3) 安装了 apex 且 4) 使用非 Windows 操作系统。
act_name (Union[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)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

monai.networks.nets.DynUnet[source]#: alias of DynUNet 的别名

monai.networks.nets.Dynunet[source]#: alias of 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')[source]#

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

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

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

选择卷积的填充值以确保如果某层的 strides 值是输入尺寸的因数，则输出尺寸是输入尺寸的偶数因数/倍数。一个典型的情况是使用 strides 值为 2，并且输入是 2 的幂的倍数。因此，输入可以被均匀下采样多次，取决于其维度可以被 2 整除多少次，所以对于示例网络，输入必须具有 4 的倍数的维度。在下面给出的第二个示例网络中，输入形状为 (1, 1, 240, 240) 时，底层输入将具有形状 (1, 64, 15, 15)，这表明输入在空间尺寸上被 2**4 缩小。

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
channels – 通道序列。顶部块优先。channels 的长度应不小于 2。
strides – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size – 卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
up_kernel_size – 上采样卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
num_res_units – 残差单元数量。默认为 0。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
dropout – Dropout 率。默认为不使用 Dropout。
bias –
是否在卷积块中包含偏置项。默认为 True。根据 Performance Tuning Guide，如果一个卷积层直接跟随批量归一化层，则 bias 应为 False。
adn_ordering – 表示激活（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)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: Tensor

monai.networks.nets.Unet[source]#: alias of UNet 的别名

monai.networks.nets.unet[source]#: alias of <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)[source]#

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

参数:

spatial_dims – 输入图像的空间维度数。
in_channels – 输入通道的数量。
out_channels – 输出类别的数量。
channels (Sequence[int]) – 通道序列。顶部块优先。channels 的长度应不小于 2。
strides (Sequence[int]) – 用于卷积的步长。
kernel_size – 卷积核大小。
up_kernel_size – 转置卷积层的卷积核尺寸。
dropout – Dropout 率。默认为不使用 Dropout。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[source]#

基于：“Hatamizadeh et al., 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)[source]#

参数:

in_channels – 输入通道的维度。
out_channels – 输出通道的维度。
img_size – 输入图像的维度。
feature_size – 网络特征尺寸的维度。默认为 16。
hidden_size – 隐藏层的维度。默认为 768。
mlp_dim – 前馈层的维度。默认为 3072。
num_heads – 注意力头的数量。默认为 12。
proj_type – Patch 嵌入层类型。默认为 “conv”。
norm_name – 特征归一化类型和参数。默认为 “instance”。
conv_block – 是否使用卷积块。默认为 True。
res_block – 是否使用残差块。默认为 True。
dropout_rate – 丢弃的输入单元比例。默认为 0.0。
spatial_dims – 空间维度数。默认为 3。
qkv_bias – 是否在自注意力块中为 qkv 线性层应用偏置项。默认为 False。
save_attn – 是否在自注意力块中使注意力可访问。默认为 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)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

VISTA3D#

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

基于: VISTA3D: Versatile Imaging SegmenTation and Annotation model for 3D Computed Tomography.

参数:

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

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

将自动结果与点选响应结合。自动结果的形状为 [B, 1, H, W, D]，这意味着来自单个图像 Patch 的 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))[source]#

根据其类别提示转换点标签。对于在 special index 中定义的特殊类别，正/负点标签将从 1/0 转换为 3/2。目的是将这些类别与模糊类别区分开。

参数:

point_label – 点标签张量，[B, N]。
label_set – 与 labels 中的索引匹配的标签索引。如果使用 RelabelID 将标签映射到 global index，则此 label_set 应为全局映射索引。如果标签未映射到 global index，例如在 zero-shot evaluation 中，此 label_set 应为原始索引。
special_index – 需要转换的特殊类别索引。

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)[source]#

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

参数:

input_images – [1, 1, H, W, D]
point_coords – [B, N, 3]
point_labels – [B, N]，-1 表示填充。0/1 表示常规类别的负/正点。2/3 表示特殊支持类别（如肿瘤）的负/正点。
class_vector – [B, 1]，全局类别索引。
prompt_class – [B, 1]，全局类别索引。此值与 point_coords 相关联，用于识别点是用于零样本（zero-shot）类别还是支持的类别。当 class_vector 和 point_coords 都提供时，prompt_class 与 class_vector 相同。对于 prompt_class[b] > 512 的情况，point_coords[b] 将被视为新类别。
patch_coords – 表示滑动窗口推理期间 Patch 坐标的 Python slice 对象序列列表。此值从 sliding_window_inferer 传入。这是训练阶段或验证阶段的指示符。请注意，对于滑动窗口批量大小 > 1（仅由自动分割支持），patch_coords 将包含多个 Patch 的坐标。如果包含点提示，则批量大小只能为一，并且所有使用 patch_coords 的函数将默认使用 patch_coords[0]。
labels – [1, 1, H, W, D]，地面真值标签张量，仅用于仅点评估。
label_set – 与 labels 中的索引匹配的标签索引。如果使用 RelabelID 将标签映射到 global index，则此 label_set 应为全局映射索引。如果标签未映射到 global index，例如在 zero-shot evaluation 中，此 label_set 应为原始索引。
prev_mask – [B, N, H_fullsize, W_fullsize, D_fullsize]。这是来自 sliding_window_inferer 的转置原始输出，未经过任何后处理。当用户点击点来执行自动结果修正时，这可以是自动结果。
radius – 控制组合点结果和自动结果时高斯模糊的单个浮点值。高斯组合在 VISTA3D 训练中未使用，但可能对微调目的有用。
val_point_sampler – 用于从 labels 中采样点的函数。仅用于仅点评估。
transpose – bool 类型。如果为 true，输出将被转置为 [1, B, H, W, D]。从 sliding window inferer/point inferer 调用时必须为 true。

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

使用高斯组合点结果和自动结果。

参数:

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

get_foreground_class_count(class_vector, point_coords)[source]#: 根据类别和点提示获取前景类别数量。

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

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

参数:

labels – 形状 [1, 1, H, W, D]。
patch_coords – 滑动窗口 slice 对象的序列。
label_set – 本地索引，必须匹配 labels 中的值。
use_center – 从中心采样点。
mapped_label_set – global index，用于识别特殊类别，是采样点的 global index。
max_ppoint/max_npoint – 要采样的正点和负点。

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

冻结自动分支或点分支。

参数:

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

update_point_to_patch(patch_coords, point_coords, point_labels)[source]#

更新 point_coords 相对于 Patch 坐标。如果点在 Patch 外部，则移除坐标并将标签设置为 -1。

参数:

patch_coords (Sequence[slice]) – 表示滑动窗口推理期间 Patch 坐标的 Python slice 对象序列。此值从 sliding_window_inferer 传入。
point_coords (Tensor) – 点坐标，[B, N, 3]。
point_labels (Tensor) – 点标签，[B, N]。

update_slidingwindow_padding(pad_size, labels, prev_mask, point_coords)[source]#

图像已被 sliding window inferer 填充。相关的填充需要在 slidingwindow inferer 外部执行。

参数:

pad_size – 从 sliding window inferer 传入的填充尺寸。
labels – 图像标签地面真值。
prev_mask – 上一个分割掩码。
point_coords – 点选坐标。

SwinUNETR#

class monai.networks.nets.SwinUNETR(img_size, in_channels, out_channels, depths=(2, 2, 2, 2), num_heads=(3, 6, 12, 24), feature_size=24, norm_name='instance', drop_rate=0.0, attn_drop_rate=0.0, dropout_path_rate=0.0, normalize=True, use_checkpoint=False, spatial_dims=3, downsample='merging', use_v2=False)[source]#

基于：“Hatamizadeh et al., Swin UNETR: Swin Transformers for Semantic Segmentation of Brain Tumors in MRI Images https://arxiv.org/abs/2201.01266”

__init__(img_size, in_channels, out_channels, depths=(2, 2, 2, 2), num_heads=(3, 6, 12, 24), feature_size=24, norm_name='instance', drop_rate=0.0, attn_drop_rate=0.0, dropout_path_rate=0.0, normalize=True, use_checkpoint=False, spatial_dims=3, downsample='merging', use_v2=False)[source]#

参数:

img_size – 输入图像的空间维度。此参数仅用于检查输入图像尺寸是否可被 Patch 尺寸整除。传入 forward() 的张量可以具有动态形状，只要其空间维度可被 2**5 整除即可。此参数将在即将发布的版本中移除。
in_channels – 输入通道的维度。
out_channels – 输出通道的维度。
feature_size – 网络特征尺寸的维度。
depths – 每个阶段的层数。
num_heads – 注意力头的数量。
norm_name – 特征归一化类型和参数。
drop_rate – Dropout 比率。
attn_drop_rate – 注意力 Dropout 比率。
dropout_path_rate – Drop path 比率。
normalize – 是否对每个阶段的输出中间特征进行归一化。
use_checkpoint – 是否使用梯度检查点以减少内存使用。
spatial_dims – 空间维度数。
downsample – 用于下采样的模块，可用选项有 “mergingv2”、“merging” 以及遵循 monai.networks.nets.PatchMerging 中定义的 API 的用户指定 nn.Module。当前默认为 “merging”（v0.9.0 中定义的原始版本）。
use_v2 – 是否使用 swinunetr_v2，它在每个 Swin 阶段的开头添加一个残差卷积块。

示例

# for 3D single channel input with size (96,96,96), 4-channel output and feature size of 48.
>>> net = SwinUNETR(img_size=(96,96,96), 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(img_size=(128,128,128), 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(img_size=(96,96), in_channels=3, out_channels=2, use_checkpoint=True, spatial_dims=2)

forward(x_in)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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')[source]#

__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')[source]#

支持 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 – 空间维度数。空间 3D 输入默认为 3。
in_channels – 输入通道数。默认为 1。
out_channels – 输出通道数。默认为 2。
features –
六个整数，表示特征数量。默认为 (32, 32, 64, 128, 256, 32)，
- 前五个值对应于五级编码器的特征尺寸。
- 最后一个值对应于最后一次上采样后的特征尺寸。
act – 激活类型和参数。默认为 LeakyReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
bias –
是否在卷积块中包含偏置项。默认为 True。根据 Performance Tuning Guide，如果一个卷积层直接跟随批量归一化层，则 bias 应为 False。
dropout – Dropout 率。默认为不使用 Dropout。
upsample – 上采样模式，可用选项有 "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 以确保所有 maxpooling 输入具有偶数边长。
返回:: 形状为 (Batch, out_channels, dim_0[, dim_1, ..., dim_N-1]) 的 “原始” 预测的 torch 张量。

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

monai.networks.nets.Basicunet[source]#: monai.networks.nets.BasicUnet[source]#

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 – 空间维度数。空间 3D 输入默认为 3。
in_channels – 输入通道数。默认为 1。
out_channels – 输出通道数。默认为 2。
features –
六个整数，表示特征数量。默认为 (32, 32, 64, 128, 256, 32)，
- 前五个值对应于五级编码器的特征尺寸。
- 最后一个值对应于最后一次上采样后的特征尺寸。
deep_supervision – 推理时是否修剪网络。默认为 False。如果为 True，则返回一个列表，其元素对应于不同节点的输出。
act – 激活类型和参数。默认为 LeakyReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
bias –
是否在卷积块中包含偏置项。默认为 True。根据 Performance Tuning Guide，如果一个卷积层直接跟随批量归一化层，则 bias 应为 False。
dropout – Dropout 率。默认为不使用 Dropout。
upsample – 上采样模式，可用选项有 "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 张量。

monai.networks.nets.BasicUnetPlusPlus[源代码]#: BasicUNetPlusPlus 的别名

monai.networks.nets.BasicunetPlusPlus[源代码]#: 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)[源代码]#

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)[源代码]#

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

参数:

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

forward(inputs)[源代码]#

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

参数:: inputs (Tensor) – 输入张量，空间维度应为 N 维 (Batch, in_channels, dim_0[, dim_1, ..., dim_N])，其中 N 由 dimensions 定义。
返回:: 一个形状为 (Batch, out_channels, dim_0[, dim_1, ..., dim_N]) 的 "原始" 预测的 PyTorch 张量。

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)[源代码]#

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

参数:

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

自版本 1.2 起已弃用: dropout_prob 已弃用，请改用 dropout_prob_down 和 dropout_prob_up。

forward(x)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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)[源代码]#

实现改编 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)[源代码]#

参数:

spatial_dims – 空间维度数
in_channels – 输入通道数
num_channel_initial – 初始通道数
depth – 输入在第 0 层，底部在第 depth 层。
out_kernel_initializer – 最后一层的核初始化器
out_activation – 最后一层的激活函数
out_channels – 输出的通道数
extract_levels – 列表，从网络中提取哪些层。最大层数必须等于 depth
pooling – 对于下采样，如果为 True 则使用无参数池化，否则使用 conv
concat_skip – 上采样时，如果为 True 则拼接跳跃连接的张量，否则使用加法
encode_kernel_sizes – 下采样的核大小

forward(x)[源代码]#

参数:: 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)[源代码]#

为图像配准构建 GlobalNet。

参考: Hu, Yipeng, et al. “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)[源代码]#

参数:

image_size – 输出位移场的空间大小
spatial_dims – 空间维度数
in_channels – 输入通道数
num_channel_initial – 初始通道数
depth – 输入在第 0 层，底部在第 depth 层。
out_kernel_initializer – 最后一层的核初始化器
out_activation – 最后一层的激活函数
pooling – 对于下采样，如果为 True 则使用无参数池化，否则使用 conv
concat_skip – 上采样时，如果为 True 则拼接跳跃连接的张量，否则使用加法
encode_kernel_sizes – 下采样的核大小
save_theta – 是否保存 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)[源代码]#

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)[源代码]#

参数:

spatial_dims – 空间维度数
in_channels – 输入通道数
num_channel_initial – 初始通道数
out_kernel_initializer – 最后一层的核初始化器
out_activation – 最后一层的激活函数
out_channels – 输出的通道数
extract_levels – 列表，从网络中提取哪些层。最大层数必须等于 depth
pooling – 对于下采样，如果为 True 则使用无参数池化，否则使用 conv3d
use_additive_sampling – 解码时是否使用加法上采样层。
concat_skip – 上采样时，如果为 True 则拼接跳跃连接的张量，否则使用加法
mode – 使用 use_additive_sampling 时的插值模式，默认为 "nearest"。
align_corners – 使用 use_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)[源代码]#

自动编码器的简单定义，也是实现 monai.networks.nets.VarAutoEncoder 架构的基类。该网络由一系列编码块，接着是一系列中间块，最后是一系列解码块组成。编码块和解码块默认是 monai.networks.blocks.Convolution 实例，编码块具有给定的步长，解码块具有相同步长的转置卷积。如果给定 num_res_units，则改用残差块。

默认情况下，中间序列为空，但如果给定 inter_channels 来指定块的输出通道数，则它将成为一系列 Convolution 块，或者如果给定 num_inter_units，则成为一系列残差块。可选参数 inter_dilations 可用于指定这些块中卷积的扩张值，这使得网络可以在中间部分使用扩张核。由于中间部分不打算改变输出的大小，所有这些核的步长都为 1。

参数:

spatial_dims – 空间维度数量。
in_channels – 输入通道数量。
out_channels – 输出通道数量。
channels – 通道序列。顶部块优先。channels 的长度应不小于 2。
strides – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size – 卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
up_kernel_size – 上采样卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
num_res_units – 残差单元数量。默认为 0。
inter_channels – 定义编码器和解码器之间中间层的块的通道序列。
inter_dilations – 定义中间层每个块的扩张值。默认为 1。
num_inter_units – 中间层每个块的残差单元数。默认为 0。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
dropout – Dropout 率。默认为不使用 Dropout。
bias –
是否在卷积块中包含偏置项。默认为 True。根据 Performance Tuning Guide，如果一个卷积层直接跟随批量归一化层，则 bias 应为 False。
padding – 控制卷积块中每个维度的填充点的隐式零填充量。默认为 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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[源代码]#

基于论文 https://arxiv.org/abs/1312.6114 的变分自动编码器

参数:

spatial_dims – 空间维度数量。
in_shape – 以通道维度开头的输入数据形状。
out_channels – 输出通道数量。
latent_size – 潜在变量的大小。
channels – 通道序列。顶部块优先。channels 的长度应不小于 2。
strides – 卷积步长序列。stride 的长度应等于 len(channels) - 1。
kernel_size – 卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
up_kernel_size – 上采样卷积核尺寸，值应为奇数。如果是序列，其长度应等于维度。默认为 3。
num_res_units – 残差单元数量。默认为 0。
inter_channels – 定义编码器和解码器之间中间层的块的通道序列。
inter_dilations – 定义中间层每个块的扩张值。默认为 1。
num_inter_units – 中间层每个块的残差单元数。默认为 0。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
dropout – Dropout 率。默认为不使用 Dropout。
bias –
是否在卷积块中包含偏置项。默认为 True。根据 Performance Tuning Guide，如果一个卷积层直接跟随批量归一化层，则 bias 应为 False。
use_sigmoid – 是否在最终输出上使用 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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[源代码]#

Vision Transformer (ViT)，基于: “Dosovitskiy et al., An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>”

ViT 支持 Torchscript，但仅适用于 Pytorch 1.8 及以上版本。

__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)[源代码]#

参数:

in_channels (int) – 输入通道的维度。
img_size (Union[Sequence[int], int]) – 输入图像的维度。
patch_size (Union[Sequence[int], int]) – 补丁大小的维度。
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) – 补丁嵌入层类型。默认为 "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 时，在分类头部添加最终激活函数。默认为 "Tanh" 表示 nn.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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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)[源代码]#

Vision Transformer (ViT)，基于: “Dosovitskiy et al., 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)[源代码]#

参数:

in_channels – 输入通道的维度或输入的通道数。
img_size – 输入图像的维度。
patch_size – 补丁大小的维度
out_channels – 输出通道数。默认为 1。
deconv_chns – 反卷积层的通道数。默认为 16。
hidden_size – 隐藏层的维度。默认为 768。
mlp_dim – 前馈层的维度。默认为 3072。
num_layers – transformer 块的数量。默认为 12。
num_heads – 注意力头的数量。默认为 12。
proj_type – 位置嵌入层类型。默认为 "conv"。
dropout_rate – 丢弃的输入单元比例。默认为 0.0。
spatial_dims – 空间维度数。默认为 3。
qkv_bias – 是否在自注意力块中的 qkv 线性层应用偏置。默认为 False。
save_attn – 是否在自注意力块中保存注意力以供访问。默认为 False。默认为 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)[源代码]#

参数:: x – 输入张量必须具有各向同性的空间维度，例如 [batch_size, channels, sp_size, sp_size[, sp_size]]。

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 – 输入通道数量。
out_channels – 输出通道数量。
hidden_channels – 每个隐藏层的输出通道数。
dropout – Dropout 率。默认为不使用 Dropout。
act – 激活类型和参数。默认为 PReLU。
bias – 线性单元中是否包含偏置项。默认为 True。
adn_ordering – 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 – 输入通道数量。
out_channels – 输出通道数量。
latent_size – 要使用的潜在变量数。
encode_channels – 编码部分每个隐藏层的输出通道数。
decode_channels – 解码部分每个隐藏层的输出通道数。
dropout – Dropout 率。默认为不使用 Dropout。
act – 激活类型和参数。默认为 PReLU。
bias – 线性单元中是否包含偏置项。默认为 True。
adn_ordering – 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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 – 整数元组，表示输入潜在向量的维度（减去批处理维度）
start_shape – 整数元组，表示要传递给卷积子网络的张量维度
channels – 整数元组，表示每个卷积层的输出通道数
strides – 整数元组，表示每个卷积层的步长（上采样因子）
kernel_size – 整数或整数元组，表示卷积核的大小
num_res_units – 整数，表示残差单元中的卷积数，0 表示没有残差单元
act – 定义激活层的名称或类型
norm – 定义归一化层的名称或类型
dropout – 可选的 float 值，范围 [0, 1]，表示层的 dropout 概率，None 表示没有 dropout
bias – 布尔值，表示卷积层是否应该有偏置分量

示例

# 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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 – 整数元组，表示输入张量的维度（减去批处理维度）
out_shape – 整数元组，表示最终输出张量的维度（减去批处理维度）
channels – 整数元组，表示每个卷积层的输出通道数
strides – 整数元组，表示每个卷积层的步长（下采样因子）
kernel_size – 整数或整数元组，表示卷积核的大小
num_res_units – 整数，表示残差单元中的卷积数，0 表示没有残差单元
act – 定义激活层的名称或类型
norm – 定义归一化层的名称或类型
dropout – 可选的 float 值，范围 [0, 1]，表示层的 dropout 概率，None 表示没有 dropout
bias – 布尔值，表示卷积层是否应该有偏置分量

示例

# 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)[源代码]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 – 整数元组，表示输入张量的维度（减去批处理维度）
classes – 整数，表示最终输出张量的维度
channels – 整数元组，表示每个卷积层的输出通道数
strides – 整数元组，表示每个卷积层的步长（下采样因子）
kernel_size – 整数或整数元组，表示卷积核的大小
num_res_units – 整数，表示残差单元中的卷积数，0 表示没有残差单元
act – 定义激活层的名称或类型
norm – 定义归一化层的名称或类型
dropout – 可选的 float 值，范围 [0, 1]，表示层的 dropout 概率，None 表示没有 dropout
bias – 布尔值，表示卷积层是否应该有偏置分量
last_act – 定义最后一个激活层的名称

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 激活。这适用于需要通用判别器网络的 GAN 或其他应用。

参数:

in_shape – 整数元组，表示输入张量的维度（减去批处理维度）
channels – 整数元组，表示每个卷积层的输出通道数
strides – 整数元组，表示每个卷积层的步长（下采样因子）
kernel_size – 整数或整数元组，表示卷积核的大小
num_res_units – 整数，表示残差单元中的卷积数，0 表示没有残差单元
act – 定义激活层的名称或类型
norm – 定义归一化层的名称或类型
dropout – 可选的 float 值，范围 [0, 1]，表示层的 dropout 概率，None 表示没有 dropout
bias – 布尔值，表示卷积层是否应该有偏置分量
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)[source]#

定义了一个来自 Classifier 的 critic 网络，具有单个输出值且没有最终激活。最后一层是 nn.Flatten 而不是 nn.Linear，最终结果计算为第一维的平均值。这旨在与 Wasserstein GANs 一起使用。

参数:

in_shape – 整数元组，表示输入张量的维度（减去批处理维度）
channels – 整数元组，表示每个卷积层的输出通道数
strides – 整数元组，表示每个卷积层的步长（下采样因子）
kernel_size – 整数或整数元组，表示卷积核的大小
num_res_units – 整数，表示残差单元中的卷积数，0 表示没有残差单元
act – 定义激活层的名称或类型
norm – 定义归一化层的名称或类型
dropout – 可选的 float 值，范围 [0, 1]，表示层的 dropout 概率，None 表示没有 dropout
bias – 布尔值，表示卷积层是否应该有偏置分量

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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')[source]#

基于 “Hatamizadeh et al.,TransCheX: Self-Supervised Pretraining of Vision-Language Transformers for Chest X-ray Analysis” 的 TransChex 模型。

__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')[source]#

参数:

in_channels – 输入通道的维度。
img_size – 输入图像的维度。
patch_size – Patch 大小的维度。
num_classes – 分类任务使用的类别数量。
num_language_layers – 语言 transformer 层的数量。
num_vision_layers – 视觉 transformer 层的数量。
num_mixed_layers – 混合 transformer 层的数量。
drop_out – 输入单元的 dropout 比例。
path_or_repo_id – 可以是以下之一：- 一个字符串，huggingface.co 上模型仓库的 模型 ID。- 一个包含该文件的目录路径。
filename – 要在 path_or_repo 中定位的文件名。

其他参数是 bert_config 到 MultiModal.from_pretrained 的一部分。

示例

# 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)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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='')[source]#

用于将模型的最后一层替换为卷积层或 FC 层的包装器。

另请参阅： monai.networks.nets.TorchVisionFCModel

参数:

model – 一个 PyTorch 模型，可以是 2D 或 3D 模型。通常，它可以是 Torchvision 中的预训练模型，例如：resnet18, resnet34, resnet50, resnet101, resnet152 等。更多详情：https://pytorch.ac.cn/vision/stable/models.html。
num_classes – 最后一层分类的类别数量。默认为 1。
dim – 指定模型中支持的空间维度数量，取决于模型的实现。默认为 2，因为大多数 Torchvision 模型用于 2D 图像处理。
in_channels – 最后一层的输入通道数量。如果为 None，则从最后一层的 in_features 获取。
use_conv – 是否使用卷积层替换最后一层，默认为 False。
pool – 池化层参数，应该是一个元组，第一个项是池化层名称，第二个项是初始化参数的字典。如果为 None，将不会替换 layers[-2]。默认为 (“avg”, {“kernel_size”: 7, “stride”: 1})。
bias – 替换最后一层时的偏置值。如果为 False，该层将不会学习附加偏置，默认为 True。
fc_name – 最后一个全连接层对应的层属性。默认为 "fc"。
node_name – model 对应的特征提取器节点名称。默认为 “”，表示不使用提取器。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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)[source]#

自定义（预训练的）TorchVision 模型的全连接层，或将其替换为卷积层。

该类支持两种主要用例：

使用 pool=None 表示不对池化层进行修改。应与 fc_name 一起使用，以定位要修改的目标 FC 层：在这种情况下，该类将加载一个 torchvision 分类模型，将最后一个全连接 (FC) 层替换为一个新的 FC 层，新层有 num_classes 个输出。例如输入参数：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 – 尾部带全连接层的任何 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 – 最后一层分类的类别数量。默认为 1。
dim – 指定模型中支持的空间维度数量，取决于模型的实现。默认为 2，因为大多数 Torchvision 模型用于 2D 图像处理。
in_channels – 最后一层的输入通道数量。如果为 None，则从最后一层的 in_features 获取。
use_conv – 是否使用卷积层替换最后一层，默认为 False。
pool – 池化层参数，当它是元组时，第一个项是池化层名称，第二个项是初始化参数的字典。如果为 None，将不会替换 layers[-2]。默认为 (“avg”, {“kernel_size”: 7, “stride”: 1})。"" 表示不添加池化层。
bias – 替换最后一层时的偏置值。如果为 False，该层将不会学习附加偏置，默认为 True。
pretrained – 是否使用 imagenet 预训练权重。默认为 False。
fc_name – 最后一个全连接层对应的层属性。默认为 "fc"。
node_name – 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)[source]#

多实例学习 (MIL) 模型，带有骨干分类模型。目前，它仅适用于 2D 图像，典型用例是数字病理学全玻片图像分类。输入数据的预期形状是 [B, N, C, H, W]，其中 B 是 PyTorch Dataloader 的 batch_size，N 是从批次中每个原始图像提取的实例数量。教程示例可在以下位置找到：Project-MONAI/tutorials。

参数:

num_classes – 输出类别的数量。
mil_mode –
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 pyramid MIL https://arxiv.org/abs/2111.01556。
pretrained – 使用预训练权重初始化骨干网络，默认为 True。
backbone – 骨干分类器 CNN（None、返回特征的 nn.Module 或 torchvision 模型的字符串名称）。默认为 None，在这种情况下使用 ResNet50。
backbone_num_features – 骨干 CNN 的输出特征数量。默认为 None（仅在使用自定义骨干网络时需要）
trans_blocks – TransformEncoder 层中的块数量。
trans_dropout – TransformEncoder 层中的 dropout 比率。

forward(x, no_head=False)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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)[source]#

根据 “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 是一个多路径拓扑和单元操作搜索空间。架构代码将初始化为一。

TopologyConstruction 是构建实例和搜索空间的父类。

为了满足结构要求，每个空间维度的输入大小应可被 2 ** (num_depths + 1) 整除。

参数:

dints_space – DiNTS 搜索空间。值应为 TopologyInstance 或 TopologySearch 的实例。
in_channels – 输入图像通道数量。
num_classes – 输出分割类别数量。
act_name – 激活函数名称，默认为 'RELU'。
norm_name – 卷积块中使用的归一化。默认为 InstanceNorm。
spatial_dims – 空间 2D 或 3D 输入。
use_downsample – 在干（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 不能为空。

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 –
[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 – 调整中间通道数量，默认为 1。
cell – 每个节点的操作。
num_blocks – DiNTS 搜索空间的块数量（水平方向的深度）。
num_depths – DiNTS 搜索空间的图像分辨率数量：每个维度为 1, 1/2, 1/4 …。
use_downsample – 在干（stem）中使用下采样。如果为 False，搜索空间分辨率为 [1, 1/2, 1/4, 1/8]；如果为 True，搜索空间分辨率为 [1/2, 1/4, 1/8, 1/16]。
device – ‘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（最高分辨率），第三、第四、第五条路径连接到节点 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(): 获取估计的 RAM 成本。

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, paths) 转换为节点激活 (1, nodes)
node_act_list: 所有节点激活 [2^num_depths-1, depth]。对于深度 = 4，有 15 种节点激活模式，每种长度为 4。例如，[1,1,0,0] 表示节点 0、1 被激活（有输入路径）。

__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, paths) 转换为节点激活 (1, nodes)

node_act_list: 所有节点激活 [2^num_depths-1, depth]。对于深度 = 4，有 15 种节点激活
模式，每种长度为 4。例如，[1,1,0,0] 表示节点 0、1 被激活（有输入路径）。

node_act_list: 所有节点激活 [2^num_depths-1, depth]。对于深度 = 4，有 15 种节点激活模式，每种长度为 4。例如，[1,1,0,0] 表示节点 0、1 被激活（有输入路径）。

get_prob_a(child=False)[source]#

从架构权重 log_alpha_a 中获取最终路径和子模型概率。这用于前向传播、获取训练损失和最终解码。

参数:

child (bool) – 返回子概率（用于解码）

返回:

路径激活概率，大小为: [块数量，每个块中的路径数量]。对于 12 个块、4 层深度的搜索空间，大小为 [12,10]
probs_a: 所有子模型的概率（大小 1023x10）。每个子模型是一个路径激活模式: （对于 10 条路径，是长度为 10 的 1D 向量）。总共有 1023 个子模型（2^10 -1）

返回类型:

arch_code_prob_a

get_ram_cost_usage(in_size, full=False)[source]#

获取估计的输出张量大小以近似 RAM 消耗。

参数:

in_size – 最高分辨率级别的输入图像形状（4D/5D，[BCHW[D]]）。
full (bool) – 所有概率为 1 时的总 RAM 成本使用。

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 – 空间维度数量。
features – 六个整数，表示特征数量。表示每层通道数量。
act – 激活类型和参数。默认为 LeakyReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
bias – 卷积块中是否包含偏置项。默认为 True。
dropout – dropout 比率。默认为 0.0。
upsample – 上采样模式，可用选项有 "deconv"、"pixelshuffle"、"nontrainable"。
pad_factor – 一个整数，表示每个填充后的维度可被其整除的数字。例如，16 表示填充后每个维度可被 16 整除。
conv_net – 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，但用户也可以指定。学习在欠采样 kspace 的中心进行（该区域是完全采样的）。

数据必须是（复数）2 通道张量才能使用此模型。

修改并采用自：facebookresearch/fastMRI

参数:

spatial_dims – 空间维度数量。
features – 六个整数，表示特征数量。表示每层通道数量。
act – 激活类型和参数。默认为 LeakyReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
bias – 卷积块中是否包含偏置项。默认为 True。
dropout – dropout 比率。默认为 0.0。
upsample – 上采样模式，可用选项有 "deconv"、"pixelshuffle"、"nontrainable"。
coil_dim – 数据中的线圈维度
conv_net – 用于估计线圈敏感度图的学习模型。默认为 monai.apps.reconstruction.networks.nets.complex_unet。模型唯一的约束是输入和输出通道数量必须为 2。

forward(masked_kspace, mask)[source]#

参数:

masked_kspace (Tensor) – 欠采样的 kspace（即输入测量值）。2D 数据的形状为 (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

返回:

预测的线圈敏感度图，2D 数据的形状为 (B,C,H,W,2)，3D 数据的形状为 (B,C,H,W,D,2)。

get_fully_sampled_region(mask)[source]#

提取 kspace 的完全采样部分的大小。请注意，当 kspace 欠采样时，其中心的一部分是完全采样的。此部分称为自动校准区域 (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 等人的“用于加速 MRI 重建的端到端变分网络”的端到端变分网络（或简称 e2e-VarNet）。它包含多个级联，每个级联由细化和数据一致性步骤组成。网络接收欠采样的 kspace 并估计地面真实重建结果。

修改并采用自：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) – 欠采样的 kspace。2D kspace 的形状为 (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

返回:

重建后的图像，是预测 kspace 的逆傅立叶变换的绝对值的平方根和 (rss): （注意 rss 将线圈图像合并为一个图像）。

DAF3D#

class monai.networks.nets.DAF3D(in_channels, out_channels, visual_output=False)[source]#

基于 'Deep Attentive Features for Prostate Segmentation in 3D Transrectal Ultrasound' <https://arxiv.org/pdf/1907.01743.pdf> 的 DAF3D 网络。该网络包含一个 3D 特征金字塔网络，应用于 3D ResNet 的特征图上，后接一个自定义注意力模块和一个 ASPP 模块。在训练过程中，监督信号包括 FPN 的输出（四个单层特征，SLFs）、注意力模块的输出（四个注意力特征）和最终预测。它们单独与地面真实进行比较，最终损失由所有单独损失的加权和组成（详细信息请参阅 DAF3D 教程）。在验证模式下，还可以选择返回所有监督信号和注意力图，以可视化网络的内部功能。

参数:

in_channels – 输入通道数量。
out_channels – 输出通道数量。
visual_output – 在验证模式下是否返回所有 SLFs、注意力图、精细 SLFs，可用于可视化网络的内部功能

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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]#

快速分割神经解剖结构（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 架构。所有编码器和解码器都由三个卷积层组成，每个层都带有批量归一化和 ReLU。前两个卷积层后接一个连接层，用于将输入特征图与当前和先前卷积块的输出连接起来。前两个卷积层的核大小为 5x5，第三个卷积层的核大小为 1x1。

编码器路径中的数据使用最大池化层进行下采样，而不是像 UNet 那样进行上采样；解码器路径中使用最大反池化层进行上采样，而不是使用转置卷积。池化在块的开头进行，反池化在其后进行。编码器中的最大池化索引通过层转发，以便相应的解码器可以使用它们。

瓶颈块由一个 5x5 卷积层和一个批量归一化层组成，用于分隔网络的编码器和解码器部分，限制编码器和解码器之间的信息流。

最后一个解码器块的输出特征图传递给分类器块，这是一个核大小为 1x1 的卷积层，将输入映射到 N 个通道的特征图，其中 N 是分割类别的数量。

原始的 QuickNAT 实现包含一个 enable_test_dropout() 机制，用于在测试期间估计不确定性。由于 dropout 层是该网络中唯一的随机组成部分，在测试或推理时调用 train() 方法而不是 eval() 具有相同的效果。

参数:

num_classes – 要分割的类别数量（输出通道）。
num_channels – 输入通道数量。
num_filters – Dense Block 中每个卷积层的输出通道数量。
kernel_size – Dense Block 中每个卷积层的核大小。
kernel_c – 分类器块核的卷积核大小。
stride_convolution – 卷积步长。默认为 1。
pool – 池化层的核大小，
stride_pool – 池化层的步长。
se_block – 要包含的 Squeeze and Excite 块类型，默认为 None。有效选项：NONE, CSE, SSE, CSSE，
droup_out – dropout 比率。默认为不使用 dropout。
act – 激活类型和参数。默认为 PReLU。
norm – 特征归一化类型和参数。默认为实例归一化。
adn_ordering – 表示激活 (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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 – 空间维度数量。
in_channels – 拼接移动图像和固定图像后输入体积中的通道数量。
unet_out_channels – UNet 输出中的通道数量。
channels – UNet 每层中的通道数量。有关更多详细信息，请参阅以下示例。
final_conv_channels – 最终卷积块每层中的通道数量。
final_conv_act – 最终卷积块的激活函数类型。默认为 LeakyReLU。由于 VoxelMorph 最初在 tensorflow 中实现，其中 LeakyReLU 的默认负斜率为 0.2，我们在此使用相同的默认值。
kernel_size – UNet 中所有卷积层的核大小。默认为 3。
up_kernel_size – UNet 上采样路径中所有卷积层的核大小。默认为 3。
act – UNet 中所有卷积层的激活函数类型。默认为负斜率为 0.2 的 LeakyReLU。
norm – UNet 中所有卷积层的特征归一化类型和参数。默认为 None。
dropout – UNet 中所有卷积层的 dropout 比率。默认为 0.0（无 dropout）。
bias – UNet 中所有卷积层是否使用偏置。默认为 True。
use_maxpool – UNet 下采样路径中是否使用最大池化。默认为 True。使用最大池化与 VoxelMorph 的原始实现一致。但可以选择使用跨步卷积（即设置 use_maxpool 为 False）。
adn_ordering – 激活、dropout 和归一化的顺序。默认为“NDA”。

forward(concatenated_pairs)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

返回类型:: 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 时，首先沿通道维度连接输入的移动图像和固定图像，然后通过指定的骨干网络，在非微分同胚变体中（即当 integration_steps 设置为 0 时）生成位移场 (DDF) 的预测，或在微分同胚变体中（即当 integration_steps 设置为正整数时）生成静态速度场 (DVF)。然后使用缩放平方方法通过 monai.networks.blocks.warp.DVF2DDF 模块对 DVF 进行积分以生成 DDF。最后，使用 monai.networks.blocks.warp.Warp 模块使用 DDF 将移动图像形变到固定图像。可选地，通过指定 half_res 为 True，可以在较低分辨率下执行从 DVF 到 DDF 的积分，在这种情况下，骨干网络的输出 DVF 首先被线性插值到半分辨率，然后再进行积分。然后输出 DDF 再次线性插值回全分辨率，再用于形变移动图像。

参数:

backbone – 骨干网络。
integration_steps – 用于通过缩放平方方法从 DVF 获取 DDF 的积分步数。默认为 7。如果设置为 0，则网络为非微分同胚。
half_res – 是否在半分辨率下执行积分。默认为 False。
spatial_dims – 空间维度数量，默认为 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]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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

实用工具#

用于定义网络的实用工具和类型，这些依赖于 PyTorch。

class monai.networks.utils.CastTempType(initial_type, temporary_type, submodule)[source]#

在应用子模块之前将输入张量转换为临时类型，然后将其转换回初始类型。

forward(x)[source]#

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

应被所有子类覆盖。

注意

虽然前向传播的实现需要在该函数中定义，但后续应调用 Module 实例而非直接调用此函数，因为前者负责运行注册的钩子，而后者会默默忽略它们。

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, dynamo=False, **kwargs)[source]#

将模型转换为 ONNX 模型并可选地使用 ONNX 或 onnxruntime 进行验证的实用工具。另请参阅：https://pytorch.ac.cn/docs/stable/onnx.html 了解如何将 PyTorch 模型转换为 ONNX。

参数:

model – 要保存的源 PyTorch 模型。
inputs – pytorch.onnx.export 使用的输入样本数据。也用于 ONNX 模型验证。
input_names – ONNX 模型的可选输入名称。
output_names – ONNX 模型的可选输出名称。
opset_version – 目标 (ai.onnx) opset 版本。必须 >= 7 且不超过
PyTorch (the latest opset version supported by) – PyTorch 支持的最新 opset 版本 - onnx/onnx 和 pytorch/pytorch
details (for more) – 更多详细信息请参阅 onnx/onnx 和 pytorch/pytorch
dynamic_axes – 将张量的轴指定为动态（即仅在运行时已知）。如果设置为 None，则导出的模型所有输入和输出张量的形状将与给定的一致，更多详细信息：https://pytorch.ac.cn/docs/stable/onnx.html#torch.onnx.export。
filename – 可选的文件名，用于保存 ONNX 模型，如果为 None，则不保存 ONNX 模型。
verify – 是否使用 ONNX 或 onnxruntime 验证 ONNX 模型。
device – 用于验证模型的 PyTorch 目标设备，如果为 None，则使用可用的 CUDA。
use_ort – 是否使用 onnxruntime 验证模型。
ort_provider" – 要使用的 onnxruntime 提供程序，默认为 [“CPUExecutionProvider”]。
rtol – 比较 PyTorch 模型和 TorchScript 模型输出时的相对容差。
atol – 比较 PyTorch 模型和 TorchScript 模型输出时的绝对容差。
use_trace – 是否使用 torch.jit.trace 导出 torchscript 模型。
do_constant_folding – 传递给 onnx.export()。如果为 True，则进行额外的 polygraphy 折叠过程。
constant_size_threshold – 传递给 polygrapy constant folding，默认为 16M
kwargs – 如果 use_trace=True：传递给 torch.onnx.export() 的其他参数，否则：torch.jit.script() 转换模型时除 obj 外的其他参数，更多详细信息：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 – 要保存的源 PyTorch 模型。
filename_or_obj – 如果不为 None，则指定一个类似文件的对象（必须实现 write 和 flush）或一个包含文件路径名的字符串，用于保存 TorchScript 模型。
extra_files – 从文件名到内容的映射，将作为保存的模型文件的一部分存储。更多详细信息：https://pytorch.ac.cn/docs/stable/generated/torch.jit.save.html。
verify – 是否验证 TorchScript 模型的输入和输出。如果 filename_or_obj 不为 None，则加载已保存的 TorchScript 模型并进行验证。
inputs – 用于验证模型的输入测试数据，应为一个数据序列，每个项映射到 model() 函数的一个参数。
device – 用于验证模型的目标设备，如果为 None，则使用可用的 CUDA。
rtol – 比较 PyTorch 模型和 TorchScript 模型输出时的相对容差。
atol – 比较 PyTorch 模型和 TorchScript 模型输出时的绝对容差。
use_trace – 是否使用 torch.jit.trace 导出 TorchScript 模型。
kwargs – torch.jit.script() 或 torch.jit.trace()（如果 use_trace 为 True）转换模型时除 obj 外的其他参数，更多详细信息：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 引擎。然而，通过第二种方式导出时，某些 Python 数据结构（如 dict）不受支持。并且如果通过 torch.jit.script 导出，一些 TorchScript 模型不受 ONNX 支持。

参数:

model – 要转换的源 PyTorch 模型。
precision – 转换后的基于 TensorRT 引擎的 TorchScript 模型的权重精度。应为 ‘fp32’ 或 ‘fp16’。
input_shape – 用于转换模型的输入形状。应为 [N, C, H, W] 或 [N, C, H, W, D] 等列表。
dynamic_batchsize – 一个包含三个元素的序列，用于定义要转换模型的输入的批次大小范围。应为 [MIN_BATCH, OPT_BATCH, MAX_BATCH] 等序列。转换后，模型输入的批次大小应介于 MIN_BATCH 和 MAX_BATCH 之间，OPT_BATCH 是 TensorRT 尝试适配的最佳性能批次大小。OPT_BATCH 应为应用程序中最常用的输入批次大小，默认为 None。
use_trace – 是否使用 torch.jit.trace 将 PyTorch 模型转换为 TorchScript 模型，然后再转换为基于 TensorRT 引擎的 TorchScript 模型或 ONNX 模型（如果 use_onnx 为 True），默认为 False。
filename_or_obj – 如果不为 None，则指定一个类似文件的对象（必须实现 write 和 flush）或一个包含文件路径名的字符串，用于加载基于 TensorRT 引擎的 TorchScript 模型进行验证。
verify – 是否验证基于 TensorRT 引擎的 TorchScript 模型的输入和输出。
device – 用于转换和验证模型的目标 GPU 索引。如果为 None，则使用 #0 GPU。
use_onnx – 是否使用 ONNX-TensorRT 方式导出基于 TensorRT 引擎的 TorchScript 模型。
onnx_input_names – ONNX 模型的可选输入名称。此参数仅在 use_onnx 为 True 时有用。应为 (‘input_0’, ‘input_1’, …, ‘input_N’) 等序列，其中 N 等于模型输入的数量。如果未给出，将使用 (‘input_0’,)，这假定模型只有一个输入。
onnx_output_names – ONNX 模型的可选输出名称。此参数仅在 use_onnx 为 True 时有用。应为 (‘output_0’, ‘output_1’, …, ‘output_N’) 等序列，其中 N 等于模型输出的数量。如果未给出，将使用 (‘output_0’,)，这假定模型只有一个输出。
rtol – 比较 PyTorch 模型和 TensorRT 模型输出时的相对容差。
atol – 比较 PyTorch 模型和 TensorRT 模型输出时的绝对容差。
kwargs – torch_tensorrt.compile() 编译模型时除 module, inputs, enabled_precisions 和 device 外的其他参数，更多详细信息：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 – 要更新的 pytorch 模块或 state dict。
src – 用于获取更新值的 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 state 的 OrderedDict，以及已更改和未更改的键。

monai.networks.utils.eval_mode(*nets)#

将网络设置为 eval 模式，并在结束时恢复原始状态。

参数:: 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 计算 min/opt/max 形状。

monai.networks.utils.get_state_dict(obj)[source]#

如果输入对象有 state_dict，则获取其 state dict，否则直接返回对象。对于数据并行模型，先自动将其转换为常规模型。

参数:: obj – 要检查并获取 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]#

使用标准差为 std 的正态分布值初始化 m 及其子模块的权重和偏置张量。卷积层和线性层的权重张量用均值为 0 初始化，批量归一化层用均值为 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 – 返回的仿射矩阵将被分配到的设备。
dtype – 返回的仿射矩阵的数据类型
align_corners – 如果为 True，则将 -1 和 1 视为角像素的中心，而不是图像的角。另请参阅：https://pytorch.ac.cn/docs/stable/nn.functional.html#torch.nn.functional.grid_sample
zero_centered – 坐标是否从零中心范围归一化，默认为 False。设置此标志和 align_corners 将共同指定归一化源范围。

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 et al., 2016, “Real-Time Single Image and Video Super-Resolution Using a nEfficient Sub-Pixel Convolutional Neural Network.”

参阅：Aitken et al., 2017, “Checkerboard artifact free sub-pixel convolution”.

参数:

x (Tensor) – 输入张量
spatial_dims (int) – 空间维度数量，通常 2D 或 3D 数据分别为 2 或 3
scale_factor (int) – 空间维度重新缩放的因子，必须 >=1

返回类型:

Tensor

返回:

x 的重新排列版本。

引发:

ValueError – 当 x 的输入通道不能被 (scale_factor ** spatial_dims) 整除时

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) – 要放置在 parent 中 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 – 要保存的输入数据，可以是 nn.Module, state_dict，一个 nn.Module 或 state_dict 的字典。
path – 保存输入对象的目标文件路径。
kwargs – save_obj 的其他参数，除了 obj 和 path。默认 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)#

将网络设置为 train 模式，并在结束时恢复原始状态。

参数:: 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]#

对复数数据执行层均值-标准差归一化。对每个批次成员沿每个部分（部分指实部和虚部）分别进行归一化。

参数:

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)[源]#

填充输入以便馈入网络 (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)[源]#

返回输入的向下取整和向上取整值

参数:

n (float) – 输入数字

返回:

floor(n) (向下取整)
ceil(n) (向上取整)

返回类型:

一个元组，包含

monai.apps.reconstruction.networks.nets.utils.inverse_divisible_pad_t(x, pad_sizes)[源]#

取消网络输出的填充以匹配其原始形状

参数:

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)[源]#

分离批次和通道维度。

参数:

x (Tensor) – 对于 2D 数据，输入的形状为 (B*C,1,H,W,2)；对于 3D 数据，形状为 (B*C,1,H,W,D,2)
batch_size (int) – 批次大小

返回类型:

Tensor

返回:

输出形状为 (B,C,…)

monai.apps.reconstruction.networks.nets.utils.reshape_channel_complex_to_last_dim(x)[源]#

将复数维度与通道维度交换，使网络输出的最后一个维度为 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)[源]#

合并批次和通道维度。

参数:

x (Tensor) – 2D 数据的输入形状为 (B,C,H,W,2)，3D 数据的输入形状为 (B,C,H,W,D,2)

返回:

输出形状为 (B*C,1,…)
批次大小

返回类型:

一个元组，包含

monai.apps.reconstruction.networks.nets.utils.reshape_complex_to_channel_dim(x)[源]#

将复数维度与通道维度交换，以便网络将实部/虚部视为两个独立的通道。

参数:: 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)[源]#

根据给定的 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)[源]#

根据给定的 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

返回:

将 x 缩减到对于 2D 数据为 (B,1,H,W,2)，对于 3D 数据为 (B,1,H,W,D,2)。

网络架构#

块#

ADN#

Convolution#

CRF#

ResidualUnit#

Swish#

MemoryEfficientSwish#

FPN#

Mish#

GEGLU#

GCN 模块#

Refinement 模块#

FCN 模块#

多通道 FCN 模块#

动态 Unet 块#

DenseBlock#

SegResnet 块#

SABlock 块#

Squeeze-and-Excitation (通道挤压与激励)#

Transformer 块#

UNETR 模块#

残差挤压和激励#

挤压和激励模块#

挤压和激励瓶颈模块#

挤压和激励 Resnet 瓶颈模块#

挤压和激励 ResNeXt 瓶颈模块#

简单 ASPP#

最大平均池化#

上采样#

配准残差卷积模块#

配准下采样模块#

配准特征提取模块#

LocalNet 下采样模块#

LocalNet 上采样模块#

LocalNet 特征提取模块#

MLP 模块#

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#

ConjugateGradient#

Utilities#

Nets#