Class SegResNetDS2

monai/networks/nets/segresnet_ds.py:444–569

SegResNetDS2 adds an additional decorder branch to SegResNetDS and is the image encoder of VISTA3D `_. Args: spatial_dims: spatial dimension of the input data. Defaults to 3. init_filters: number of output channels for initial convolut

class SegResNetDS2(SegResNetDS):
    """
    SegResNetDS2 adds an additional decorder branch to SegResNetDS and is the image encoder of VISTA3D
     <https://arxiv.org/abs/2406.05285>`_.

    Args:
        spatial_dims: spatial dimension of the input data. Defaults to 3.
        init_filters: number of output channels for initial convolution layer. Defaults to 32.
        in_channels: number of input channels for the network. Defaults to 1.
        out_channels: number of output channels for the network. Defaults to 2.
        act: activation type and arguments. Defaults to ``RELU``.
        norm: feature normalization type and arguments. Defaults to ``BATCH``.
        blocks_down: number of downsample blocks in each layer. Defaults to ``[1,2,2,4]``.
        blocks_up: number of upsample blocks (optional).
        dsdepth: number of levels for deep supervision. This will be the length of the list of outputs at each scale level.
                 At dsdepth==1,only a single output is returned.
        preprocess: optional callable function to apply before the model&#x27;s forward pass
        resolution: optional input image resolution. When provided, the network will first use non-isotropic kernels to bring
                    image spacing into an approximately isotropic space.
                    Otherwise, by default, the kernel size and downsampling is always isotropic.

    """

    def __init__(
        self,
        spatial_dims: int = 3,
        init_filters: int = 32,
        in_channels: int = 1,
        out_channels: int = 2,
        act: tuple | str = "relu",
        norm: tuple | str = "batch",
        blocks_down: tuple = (1, 2, 2, 4),
        blocks_up: tuple | None = None,
        dsdepth: int = 1,
        preprocess: nn.Module | Callable | None = None,
        upsample_mode: UpsampleMode | str = "deconv",
        resolution: tuple | None = None,
    ):
        super().__init__(
            spatial_dims=spatial_dims,
            init_filters=init_filters,
            in_channels=in_channels,
            out_channels=out_channels,
            act=act,
            norm=norm,
            blocks_down=blocks_down,
            blocks_up=blocks_up,
            dsdepth=dsdepth,
            preprocess=preprocess,
            upsample_mode=upsample_mode,
            resolution=resolution,
        )

        self.up_layers_auto = nn.ModuleList([copy.deepcopy(layer) for layer in self.up_layers])

    def forward(  # type: ignore
        self, x: torch.Tensor, with_point: bool = True, with_label: bool = True
    ) -> tuple[None | torch.Tensor | list[torch.Tensor], None | torch.Tensor | list[torch.Tensor]]: