Add files using upload-large-folder tool

.gitattributes

@@ -339,3 +339,6 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_pyth
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python.libs/libxkbcommon-71ae2972.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/libnvvm.so.4.0.0 filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/sklearn/_isotonic.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/ft2font.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchvision.libs/libnvjpeg.90286a3c.so.11 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/kiwisolver/_cext.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/kiwisolver/_cext.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:847be32e761c90dedc0a587a45e0b9b1bc1d9c6a9322e3e278bad141fb8ebe90
+size 4260107

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/ft2font.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03e5cffa72fb1aaef4acef0341ad5f6bb19501fcb384aaa7e7321e570813ac51
+size 4120999

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/__init__.py

@@ -0,0 +1,31 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .convutils import calculate_out_shape, gaussian_1d, polyval, same_padding, stride_minus_kernel_padding
+from .drop_path import DropPath
+from .factories import Act, Conv, Dropout, LayerFactory, Norm, Pad, Pool, split_args
+from .filtering import BilateralFilter, PHLFilter
+from .gmm import GaussianMixtureModel
+from .simplelayers import (
+    LLTM,
+    ChannelPad,
+    Flatten,
+    GaussianFilter,
+    HilbertTransform,
+    Reshape,
+    SavitzkyGolayFilter,
+    SkipConnection,
+    apply_filter,
+    separable_filtering,
+)
+from .spatial_transforms import AffineTransform, grid_count, grid_grad, grid_pull, grid_push
+from .utils import get_act_layer, get_dropout_layer, get_norm_layer, get_pool_layer
+from .weight_init import _no_grad_trunc_normal_, trunc_normal_

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/convutils.py

@@ -0,0 +1,227 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+
+__all__ = ["same_padding", "stride_minus_kernel_padding", "calculate_out_shape", "gaussian_1d", "polyval"]
+
+
+def same_padding(
+    kernel_size: Union[Sequence[int], int], dilation: Union[Sequence[int], int] = 1
+) -> Union[Tuple[int, ...], int]:
+    """
+    Return the padding value needed to ensure a convolution using the given kernel size produces an output of the same
+    shape as the input for a stride of 1, otherwise ensure a shape of the input divided by the stride rounded down.
+
+    Raises:
+        NotImplementedError: When ``np.any((kernel_size - 1) * dilation % 2 == 1)``.
+
+    """
+
+    kernel_size_np = np.atleast_1d(kernel_size)
+    dilation_np = np.atleast_1d(dilation)
+
+    if np.any((kernel_size_np - 1) * dilation % 2 == 1):
+        raise NotImplementedError(
+            f"Same padding not available for kernel_size={kernel_size_np} and dilation={dilation_np}."
+        )
+
+    padding_np = (kernel_size_np - 1) / 2 * dilation_np
+    padding = tuple(int(p) for p in padding_np)
+
+    return padding if len(padding) > 1 else padding[0]
+
+
+def stride_minus_kernel_padding(
+    kernel_size: Union[Sequence[int], int], stride: Union[Sequence[int], int]
+) -> Union[Tuple[int, ...], int]:
+    kernel_size_np = np.atleast_1d(kernel_size)
+    stride_np = np.atleast_1d(stride)
+
+    out_padding_np = stride_np - kernel_size_np
+    out_padding = tuple(int(p) for p in out_padding_np)
+
+    return out_padding if len(out_padding) > 1 else out_padding[0]
+
+
+def calculate_out_shape(
+    in_shape: Union[Sequence[int], int, np.ndarray],
+    kernel_size: Union[Sequence[int], int],
+    stride: Union[Sequence[int], int],
+    padding: Union[Sequence[int], int],
+) -> Union[Tuple[int, ...], int]:
+    """
+    Calculate the output tensor shape when applying a convolution to a tensor of shape `inShape` with kernel size
+    `kernel_size`, stride value `stride`, and input padding value `padding`. All arguments can be scalars or multiple
+    values, return value is a scalar if all inputs are scalars.
+    """
+    in_shape_np = np.atleast_1d(in_shape)
+    kernel_size_np = np.atleast_1d(kernel_size)
+    stride_np = np.atleast_1d(stride)
+    padding_np = np.atleast_1d(padding)
+
+    out_shape_np = ((in_shape_np - kernel_size_np + padding_np + padding_np) // stride_np) + 1
+    out_shape = tuple(int(s) for s in out_shape_np)
+
+    return out_shape if len(out_shape) > 1 else out_shape[0]
+
+
+def gaussian_1d(
+    sigma: torch.Tensor, truncated: float = 4.0, approx: str = "erf", normalize: bool = False
+) -> torch.Tensor:
+    """
+    one dimensional Gaussian kernel.
+
+    Args:
+        sigma: std of the kernel
+        truncated: tail length
+        approx: discrete Gaussian kernel type, available options are "erf", "sampled", and "scalespace".
+
+            - ``erf`` approximation interpolates the error function;
+            - ``sampled`` uses a sampled Gaussian kernel;
+            - ``scalespace`` corresponds to
+              https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel
+              based on the modified Bessel functions.
+
+        normalize: whether to normalize the kernel with `kernel.sum()`.
+
+    Raises:
+        ValueError: When ``truncated`` is non-positive.
+
+    Returns:
+        1D torch tensor
+
+    """
+    sigma = torch.as_tensor(sigma, dtype=torch.float, device=sigma.device if isinstance(sigma, torch.Tensor) else None)
+    device = sigma.device
+    if truncated <= 0.0:
+        raise ValueError(f"truncated must be positive, got {truncated}.")
+    tail = int(max(float(sigma) * truncated, 0.5) + 0.5)
+    if approx.lower() == "erf":
+        x = torch.arange(-tail, tail + 1, dtype=torch.float, device=device)
+        t = 0.70710678 / torch.abs(sigma)
+        out = 0.5 * ((t * (x + 0.5)).erf() - (t * (x - 0.5)).erf())
+        out = out.clamp(min=0)
+    elif approx.lower() == "sampled":
+        x = torch.arange(-tail, tail + 1, dtype=torch.float, device=sigma.device)
+        out = torch.exp(-0.5 / (sigma * sigma) * x**2)
+        if not normalize:  # compute the normalizer
+            out = out / (2.5066282 * sigma)
+    elif approx.lower() == "scalespace":
+        sigma2 = sigma * sigma
+        out_pos: List[Optional[torch.Tensor]] = [None] * (tail + 1)
+        out_pos[0] = _modified_bessel_0(sigma2)
+        out_pos[1] = _modified_bessel_1(sigma2)
+        for k in range(2, len(out_pos)):
+            out_pos[k] = _modified_bessel_i(k, sigma2)
+        out = out_pos[:0:-1]
+        out.extend(out_pos)
+        out = torch.stack(out) * torch.exp(-sigma2)
+    else:
+        raise NotImplementedError(f"Unsupported option: approx='{approx}'.")
+    return out / out.sum() if normalize else out  # type: ignore
+
+
+def polyval(coef, x) -> torch.Tensor:
+    """
+    Evaluates the polynomial defined by `coef` at `x`.
+
+    For a 1D sequence of coef (length n), evaluate::
+
+        y = coef[n-1] + x * (coef[n-2] + ... + x * (coef[1] + x * coef[0]))
+
+    Args:
+        coef: a sequence of floats representing the coefficients of the polynomial
+        x: float or a sequence of floats representing the variable of the polynomial
+
+    Returns:
+        1D torch tensor
+    """
+    device = x.device if isinstance(x, torch.Tensor) else None
+    coef = torch.as_tensor(coef, dtype=torch.float, device=device)
+    if coef.ndim == 0 or (len(coef) < 1):
+        return torch.zeros(x.shape)
+    x = torch.as_tensor(x, dtype=torch.float, device=device)
+    ans = coef[0]
+    for c in coef[1:]:
+        ans = ans * x + c
+    return ans  # type: ignore
+
+
+def _modified_bessel_0(x: torch.Tensor) -> torch.Tensor:
+    x = torch.as_tensor(x, dtype=torch.float, device=x.device if isinstance(x, torch.Tensor) else None)
+    if torch.abs(x) < 3.75:
+        y = x * x / 14.0625
+        return polyval([0.45813e-2, 0.360768e-1, 0.2659732, 1.2067492, 3.0899424, 3.5156229, 1.0], y)
+    ax = torch.abs(x)
+    y = 3.75 / ax
+    _coef = [
+        0.392377e-2,
+        -0.1647633e-1,
+        0.2635537e-1,
+        -0.2057706e-1,
+        0.916281e-2,
+        -0.157565e-2,
+        0.225319e-2,
+        0.1328592e-1,
+        0.39894228,
+    ]
+    return polyval(_coef, y) * torch.exp(ax) / torch.sqrt(ax)
+
+
+def _modified_bessel_1(x: torch.Tensor) -> torch.Tensor:
+    x = torch.as_tensor(x, dtype=torch.float, device=x.device if isinstance(x, torch.Tensor) else None)
+    if torch.abs(x) < 3.75:
+        y = x * x / 14.0625
+        _coef = [0.32411e-3, 0.301532e-2, 0.2658733e-1, 0.15084934, 0.51498869, 0.87890594, 0.5]
+        return torch.abs(x) * polyval(_coef, y)
+    ax = torch.abs(x)
+    y = 3.75 / ax
+    _coef = [
+        -0.420059e-2,
+        0.1787654e-1,
+        -0.2895312e-1,
+        0.2282967e-1,
+        -0.1031555e-1,
+        0.163801e-2,
+        -0.362018e-2,
+        -0.3988024e-1,
+        0.39894228,
+    ]
+    ans = polyval(_coef, y) * torch.exp(ax) / torch.sqrt(ax)
+    return -ans if x < 0.0 else ans
+
+
+def _modified_bessel_i(n: int, x: torch.Tensor) -> torch.Tensor:
+    if n < 2:
+        raise ValueError(f"n must be greater than 1, got n={n}.")
+    x = torch.as_tensor(x, dtype=torch.float, device=x.device if isinstance(x, torch.Tensor) else None)
+    if x == 0.0:
+        return x
+    device = x.device
+    tox = 2.0 / torch.abs(x)
+    ans, bip, bi = torch.tensor(0.0, device=device), torch.tensor(0.0, device=device), torch.tensor(1.0, device=device)
+    m = int(2 * (n + np.floor(np.sqrt(40.0 * n))))
+    for j in range(m, 0, -1):
+        bim = bip + float(j) * tox * bi
+        bip = bi
+        bi = bim
+        if abs(bi) > 1.0e10:
+            ans = ans * 1.0e-10
+            bi = bi * 1.0e-10
+            bip = bip * 1.0e-10
+        if j == n:
+            ans = bip
+    ans = ans * _modified_bessel_0(x) / bi
+    return -ans if x < 0.0 and (n % 2) == 1 else ans

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/drop_path.py

@@ -0,0 +1,45 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch.nn as nn
+
+
+class DropPath(nn.Module):
+    """Stochastic drop paths per sample for residual blocks.
+    Based on:
+    https://github.com/rwightman/pytorch-image-models
+    """
+
+    def __init__(self, drop_prob: float = 0.0, scale_by_keep: bool = True) -> None:
+        """
+        Args:
+            drop_prob: drop path probability.
+            scale_by_keep: scaling by non-dropped probability.
+        """
+        super().__init__()
+        self.drop_prob = drop_prob
+        self.scale_by_keep = scale_by_keep
+
+        if not (0 <= drop_prob <= 1):
+            raise ValueError("Drop path prob should be between 0 and 1.")
+
+    def drop_path(self, x, drop_prob: float = 0.0, training: bool = False, scale_by_keep: bool = True):
+        if drop_prob == 0.0 or not training:
+            return x
+        keep_prob = 1 - drop_prob
+        shape = (x.shape[0],) + (1,) * (x.ndim - 1)
+        random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+        if keep_prob > 0.0 and scale_by_keep:
+            random_tensor.div_(keep_prob)
+        return x * random_tensor
+
+    def forward(self, x):
+        return self.drop_path(x, self.drop_prob, self.training, self.scale_by_keep)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/factories.py

@@ -0,0 +1,371 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Defines factories for creating layers in generic, extensible, and dimensionally independent ways. A separate factory
+object is created for each type of layer, and factory functions keyed to names are added to these objects. Whenever
+a layer is requested the factory name and any necessary arguments are passed to the factory object. The return value
+is typically a type but can be any callable producing a layer object.
+
+The factory objects contain functions keyed to names converted to upper case, these names can be referred to as members
+of the factory so that they can function as constant identifiers. eg. instance normalization is named `Norm.INSTANCE`.
+
+For example, to get a transpose convolution layer the name is needed and then a dimension argument is provided which is
+passed to the factory function:
+
+.. code-block:: python
+
+    dimension = 3
+    name = Conv.CONVTRANS
+    conv = Conv[name, dimension]
+
+This allows the `dimension` value to be set in the constructor, for example so that the dimensionality of a network is
+parameterizable. Not all factories require arguments after the name, the caller must be aware which are required.
+
+Defining new factories involves creating the object then associating it with factory functions:
+
+.. code-block:: python
+
+    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]
+
+Typically the caller of a factory would know what arguments to pass (ie. the dimensionality of the requested type) but
+can be parameterized with the factory name and the arguments to pass to the created type at instantiation time:
+
+.. code-block:: python
+
+    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) )
+"""
+
+import warnings
+from typing import Any, Callable, Dict, Tuple, Type, Union
+
+import torch
+import torch.nn as nn
+
+from monai.utils import look_up_option, optional_import
+
+InstanceNorm3dNVFuser, has_nvfuser = optional_import("apex.normalization", name="InstanceNorm3dNVFuser")
+
+
+__all__ = ["LayerFactory", "Dropout", "Norm", "Act", "Conv", "Pool", "Pad", "split_args"]
+
+
+class LayerFactory:
+    """
+    Factory object for creating layers, this uses given factory functions to actually produce the types or constructing
+    callables. These functions are referred to by name and can be added at any time.
+    """
+
+    def __init__(self) -> None:
+        self.factories: Dict[str, Callable] = {}
+
+    @property
+    def names(self) -> Tuple[str, ...]:
+        """
+        Produces all factory names.
+        """
+
+        return tuple(self.factories)
+
+    def add_factory_callable(self, name: str, func: Callable) -> None:
+        """
+        Add the factory function to this object under the given name.
+        """
+
+        self.factories[name.upper()] = func
+        self.__doc__ = (
+            "The supported member"
+            + ("s are: " if len(self.names) > 1 else " is: ")
+            + ", ".join(f"``{name}``" for name in self.names)
+            + ".\nPlease see :py:class:`monai.networks.layers.split_args` for additional args parsing."
+        )
+
+    def factory_function(self, name: str) -> Callable:
+        """
+        Decorator for adding a factory function with the given name.
+        """
+
+        def _add(func: Callable) -> Callable:
+            self.add_factory_callable(name, func)
+            return func
+
+        return _add
+
+    def get_constructor(self, factory_name: str, *args) -> Any:
+        """
+        Get the constructor for the given factory name and arguments.
+
+        Raises:
+            TypeError: When ``factory_name`` is not a ``str``.
+
+        """
+
+        if not isinstance(factory_name, str):
+            raise TypeError(f"factory_name must a str but is {type(factory_name).__name__}.")
+
+        func = look_up_option(factory_name.upper(), self.factories)
+        return func(*args)
+
+    def __getitem__(self, args) -> Any:
+        """
+        Get the given name or name/arguments pair. If `args` is a callable it is assumed to be the constructor
+        itself and is returned, otherwise it should be the factory name or a pair containing the name and arguments.
+        """
+
+        # `args[0]` is actually a type or constructor
+        if callable(args):
+            return args
+
+        # `args` is a factory name or a name with arguments
+        if isinstance(args, str):
+            name_obj, args = args, ()
+        else:
+            name_obj, *args = args
+
+        return self.get_constructor(name_obj, *args)
+
+    def __getattr__(self, key):
+        """
+        If `key` is a factory name, return it, otherwise behave as inherited. This allows referring to factory names
+        as if they were constants, eg. `Fact.FOO` for a factory Fact with factory function foo.
+        """
+
+        if key in self.factories:
+            return key
+
+        return super().__getattribute__(key)
+
+
+def split_args(args):
+    """
+    Split arguments in a way to be suitable for using with the factory types. If `args` is a string it's interpreted as
+    the type name.
+
+    Args:
+        args (str or a tuple of object name and kwarg dict): input arguments to be parsed.
+
+    Raises:
+        TypeError: When ``args`` type is not in ``Union[str, Tuple[Union[str, Callable], dict]]``.
+
+    Examples::
+
+        >>> 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)
+
+    """
+
+    if isinstance(args, str):
+        return args, {}
+    name_obj, name_args = args
+
+    if not isinstance(name_obj, (str, Callable)) or not isinstance(name_args, dict):
+        msg = "Layer specifiers must be single strings or pairs of the form (name/object-types, argument dict)"
+        raise TypeError(msg)
+
+    return name_obj, name_args
+
+
+# Define factories for these layer types
+
+Dropout = LayerFactory()
+Norm = LayerFactory()
+Act = LayerFactory()
+Conv = LayerFactory()
+Pool = LayerFactory()
+Pad = LayerFactory()
+
+
+@Dropout.factory_function("dropout")
+def dropout_factory(dim: int) -> Type[Union[nn.Dropout, nn.Dropout2d, nn.Dropout3d]]:
+    types = (nn.Dropout, nn.Dropout2d, nn.Dropout3d)
+    return types[dim - 1]
+
+
+@Dropout.factory_function("alphadropout")
+def alpha_dropout_factory(_dim):
+    return nn.AlphaDropout
+
+
+@Norm.factory_function("instance")
+def instance_factory(dim: int) -> Type[Union[nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d]]:
+    types = (nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d)
+    return types[dim - 1]
+
+
+@Norm.factory_function("batch")
+def batch_factory(dim: int) -> Type[Union[nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d]]:
+    types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)
+    return types[dim - 1]
+
+
+@Norm.factory_function("group")
+def group_factory(_dim) -> Type[nn.GroupNorm]:
+    return nn.GroupNorm
+
+
+@Norm.factory_function("layer")
+def layer_factory(_dim) -> Type[nn.LayerNorm]:
+    return nn.LayerNorm
+
+
+@Norm.factory_function("localresponse")
+def local_response_factory(_dim) -> Type[nn.LocalResponseNorm]:
+    return nn.LocalResponseNorm
+
+
+@Norm.factory_function("syncbatch")
+def sync_batch_factory(_dim) -> Type[nn.SyncBatchNorm]:
+    return nn.SyncBatchNorm
+
+
+@Norm.factory_function("instance_nvfuser")
+def instance_nvfuser_factory(dim):
+    """
+    `InstanceNorm3dNVFuser` is a faster verison of InstanceNorm layer and implemented in `apex`.
+    It only supports 3d tensors as the input. It also requires to use with CUDA and non-Windows OS.
+    In this function, if the required library `apex.normalization.InstanceNorm3dNVFuser` does not exist,
+    `nn.InstanceNorm3d` will be returned instead.
+    This layer is based on a customized autograd function, which is not supported in TorchScript currently.
+    Please switch to use `nn.InstanceNorm3d` if TorchScript is necessary.
+
+    Please check the following link for more details about how to install `apex`:
+    https://github.com/NVIDIA/apex#installation
+
+    """
+    types = (nn.InstanceNorm1d, nn.InstanceNorm2d)
+    if dim != 3:
+        warnings.warn(f"`InstanceNorm3dNVFuser` only supports 3d cases, use {types[dim - 1]} instead.")
+        return types[dim - 1]
+    # test InstanceNorm3dNVFuser installation with a basic example
+    has_nvfuser_flag = has_nvfuser
+    if not torch.cuda.is_available():
+        return nn.InstanceNorm3d
+    try:
+        layer = InstanceNorm3dNVFuser(num_features=1, affine=True).to("cuda:0")
+        inp = torch.randn([1, 1, 1, 1, 1]).to("cuda:0")
+        out = layer(inp)
+        del inp, out, layer
+    except Exception:
+        has_nvfuser_flag = False
+    if not has_nvfuser_flag:
+        warnings.warn(
+            "`apex.normalization.InstanceNorm3dNVFuser` is not installed properly, use nn.InstanceNorm3d instead."
+        )
+        return nn.InstanceNorm3d
+    return InstanceNorm3dNVFuser
+
+
+Act.add_factory_callable("elu", lambda: nn.modules.ELU)
+Act.add_factory_callable("relu", lambda: nn.modules.ReLU)
+Act.add_factory_callable("leakyrelu", lambda: nn.modules.LeakyReLU)
+Act.add_factory_callable("prelu", lambda: nn.modules.PReLU)
+Act.add_factory_callable("relu6", lambda: nn.modules.ReLU6)
+Act.add_factory_callable("selu", lambda: nn.modules.SELU)
+Act.add_factory_callable("celu", lambda: nn.modules.CELU)
+Act.add_factory_callable("gelu", lambda: nn.modules.GELU)
+Act.add_factory_callable("sigmoid", lambda: nn.modules.Sigmoid)
+Act.add_factory_callable("tanh", lambda: nn.modules.Tanh)
+Act.add_factory_callable("softmax", lambda: nn.modules.Softmax)
+Act.add_factory_callable("logsoftmax", lambda: nn.modules.LogSoftmax)
+
+
+@Act.factory_function("swish")
+def swish_factory():
+    from monai.networks.blocks.activation import Swish
+
+    return Swish
+
+
+@Act.factory_function("memswish")
+def memswish_factory():
+    from monai.networks.blocks.activation import MemoryEfficientSwish
+
+    return MemoryEfficientSwish
+
+
+@Act.factory_function("mish")
+def mish_factory():
+    from monai.networks.blocks.activation import Mish
+
+    return Mish
+
+
+@Conv.factory_function("conv")
+def conv_factory(dim: int) -> Type[Union[nn.Conv1d, nn.Conv2d, nn.Conv3d]]:
+    types = (nn.Conv1d, nn.Conv2d, nn.Conv3d)
+    return types[dim - 1]
+
+
+@Conv.factory_function("convtrans")
+def convtrans_factory(dim: int) -> Type[Union[nn.ConvTranspose1d, nn.ConvTranspose2d, nn.ConvTranspose3d]]:
+    types = (nn.ConvTranspose1d, nn.ConvTranspose2d, nn.ConvTranspose3d)
+    return types[dim - 1]
+
+
+@Pool.factory_function("max")
+def maxpooling_factory(dim: int) -> Type[Union[nn.MaxPool1d, nn.MaxPool2d, nn.MaxPool3d]]:
+    types = (nn.MaxPool1d, nn.MaxPool2d, nn.MaxPool3d)
+    return types[dim - 1]
+
+
+@Pool.factory_function("adaptivemax")
+def adaptive_maxpooling_factory(
+    dim: int,
+) -> Type[Union[nn.AdaptiveMaxPool1d, nn.AdaptiveMaxPool2d, nn.AdaptiveMaxPool3d]]:
+    types = (nn.AdaptiveMaxPool1d, nn.AdaptiveMaxPool2d, nn.AdaptiveMaxPool3d)
+    return types[dim - 1]
+
+
+@Pool.factory_function("avg")
+def avgpooling_factory(dim: int) -> Type[Union[nn.AvgPool1d, nn.AvgPool2d, nn.AvgPool3d]]:
+    types = (nn.AvgPool1d, nn.AvgPool2d, nn.AvgPool3d)
+    return types[dim - 1]
+
+
+@Pool.factory_function("adaptiveavg")
+def adaptive_avgpooling_factory(
+    dim: int,
+) -> Type[Union[nn.AdaptiveAvgPool1d, nn.AdaptiveAvgPool2d, nn.AdaptiveAvgPool3d]]:
+    types = (nn.AdaptiveAvgPool1d, nn.AdaptiveAvgPool2d, nn.AdaptiveAvgPool3d)
+    return types[dim - 1]
+
+
+@Pad.factory_function("replicationpad")
+def replication_pad_factory(dim: int) -> Type[Union[nn.ReplicationPad1d, nn.ReplicationPad2d, nn.ReplicationPad3d]]:
+    types = (nn.ReplicationPad1d, nn.ReplicationPad2d, nn.ReplicationPad3d)
+    return types[dim - 1]
+
+
+@Pad.factory_function("constantpad")
+def constant_pad_factory(dim: int) -> Type[Union[nn.ConstantPad1d, nn.ConstantPad2d, nn.ConstantPad3d]]:
+    types = (nn.ConstantPad1d, nn.ConstantPad2d, nn.ConstantPad3d)
+    return types[dim - 1]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/filtering.py

@@ -0,0 +1,101 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from monai.utils.module import optional_import
+
+_C, _ = optional_import("monai._C")
+
+__all__ = ["BilateralFilter", "PHLFilter"]
+
+
+class BilateralFilter(torch.autograd.Function):
+    """
+    Blurs the input tensor spatially whilst preserving edges. Can run on 1D, 2D, or 3D,
+    tensors (on top of Batch and Channel dimensions). Two implementations are provided,
+    an exact solution and a much faster approximation which uses a permutohedral lattice.
+
+    See:
+        https://en.wikipedia.org/wiki/Bilateral_filter
+        https://graphics.stanford.edu/papers/permutohedral/
+
+    Args:
+        input: input tensor.
+
+        spatial sigma: the standard deviation of the spatial blur. Higher values can
+            hurt performance when not using the approximate method (see fast approx).
+
+        color sigma: the standard deviation of the color blur. Lower values preserve
+            edges better whilst higher values tend to a simple gaussian spatial blur.
+
+        fast approx: This flag chooses between two implementations. The approximate method may
+            produce artifacts in some scenarios whereas the exact solution may be intolerably
+            slow for high spatial standard deviations.
+
+    Returns:
+        output (torch.Tensor): output tensor.
+    """
+
+    @staticmethod
+    def forward(ctx, input, spatial_sigma=5, color_sigma=0.5, fast_approx=True):
+        ctx.ss = spatial_sigma
+        ctx.cs = color_sigma
+        ctx.fa = fast_approx
+        output_data = _C.bilateral_filter(input, spatial_sigma, color_sigma, fast_approx)
+        return output_data
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        spatial_sigma, color_sigma, fast_approx = ctx.ss, ctx.cs, ctx.fa
+        grad_input = _C.bilateral_filter(grad_output, spatial_sigma, color_sigma, fast_approx)
+        return grad_input, None, None, None
+
+
+class PHLFilter(torch.autograd.Function):
+    """
+    Filters input based on arbitrary feature vectors. Uses a permutohedral
+    lattice data structure to efficiently approximate n-dimensional gaussian
+    filtering. Complexity is broadly independent of kernel size. Most applicable
+    to higher filter dimensions and larger kernel sizes.
+
+    See:
+        https://graphics.stanford.edu/papers/permutohedral/
+
+    Args:
+        input: input tensor to be filtered.
+
+        features: feature tensor used to filter the input.
+
+        sigmas: the standard deviations of each feature in the filter.
+
+    Returns:
+        output (torch.Tensor): output tensor.
+    """
+
+    @staticmethod
+    def forward(ctx, input, features, sigmas=None):
+
+        scaled_features = features
+        if sigmas is not None:
+            for i in range(features.size(1)):
+                scaled_features[:, i, ...] /= sigmas[i]
+
+        ctx.save_for_backward(scaled_features)
+        output_data = _C.phl_filter(input, scaled_features)
+        return output_data
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        raise NotImplementedError("PHLFilter does not currently support Backpropagation")
+        # scaled_features, = ctx.saved_variables
+        # grad_input = _C.phl_filter(grad_output, scaled_features)
+        # return grad_input

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/gmm.py

@@ -0,0 +1,85 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from monai._extensions.loader import load_module
+
+__all__ = ["GaussianMixtureModel"]
+
+
+class GaussianMixtureModel:
+    """
+    Takes an initial labeling and uses a mixture of Gaussians to approximate each classes
+    distribution in the feature space. Each unlabeled element is then assigned a probability
+    of belonging to each class based on it's fit to each classes approximated distribution.
+
+    See:
+        https://en.wikipedia.org/wiki/Mixture_model
+    """
+
+    def __init__(self, channel_count: int, mixture_count: int, mixture_size: int, verbose_build: bool = False):
+        """
+        Args:
+            channel_count: The number of features per element.
+            mixture_count: The number of class distributions.
+            mixture_size: The number Gaussian components per class distribution.
+            verbose_build: If ``True``, turns on verbose logging of load steps.
+        """
+        if not torch.cuda.is_available():
+            raise NotImplementedError("GaussianMixtureModel is currently implemented for CUDA.")
+        self.channel_count = channel_count
+        self.mixture_count = mixture_count
+        self.mixture_size = mixture_size
+        self.compiled_extension = load_module(
+            "gmm",
+            {"CHANNEL_COUNT": channel_count, "MIXTURE_COUNT": mixture_count, "MIXTURE_SIZE": mixture_size},
+            verbose_build=verbose_build,
+        )
+        self.params, self.scratch = self.compiled_extension.init()
+
+    def reset(self):
+        """
+        Resets the parameters of the model.
+        """
+        self.params, self.scratch = self.compiled_extension.init()
+
+    def learn(self, features, labels):
+        """
+        Learns, from scratch, the distribution of each class from the provided labels.
+
+        Args:
+            features (torch.Tensor): features for each element.
+            labels (torch.Tensor): initial labeling for each element.
+        """
+        self.compiled_extension.learn(self.params, self.scratch, features, labels)
+
+    def apply(self, features):
+        """
+        Applies the current model to a set of feature vectors.
+
+        Args:
+            features (torch.Tensor): feature vectors for each element.
+
+        Returns:
+            output (torch.Tensor): class assignment probabilities for each element.
+        """
+        return _ApplyFunc.apply(self.params, features, self.compiled_extension)
+
+
+class _ApplyFunc(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, params, features, compiled_extension):
+        return compiled_extension.apply(params, features)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        raise NotImplementedError("GMM does not support backpropagation")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/simplelayers.py

@@ -0,0 +1,532 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from copy import deepcopy
+from typing import List, Sequence, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.autograd import Function
+
+from monai.networks.layers.convutils import gaussian_1d
+from monai.networks.layers.factories import Conv
+from monai.utils import ChannelMatching, SkipMode, look_up_option, optional_import, pytorch_after
+from monai.utils.misc import issequenceiterable
+
+_C, _ = optional_import("monai._C")
+fft, _ = optional_import("torch.fft")
+
+__all__ = [
+    "ChannelPad",
+    "Flatten",
+    "GaussianFilter",
+    "HilbertTransform",
+    "LLTM",
+    "Reshape",
+    "SavitzkyGolayFilter",
+    "SkipConnection",
+    "apply_filter",
+    "separable_filtering",
+]
+
+
+class ChannelPad(nn.Module):
+    """
+    Expand the input tensor's channel dimension from length `in_channels` to `out_channels`,
+    by padding or a projection.
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        in_channels: int,
+        out_channels: int,
+        mode: Union[ChannelMatching, str] = ChannelMatching.PAD,
+    ):
+        """
+
+        Args:
+            spatial_dims: number of spatial dimensions of the input image.
+            in_channels: number of input channels.
+            out_channels: number of output channels.
+            mode: {``"pad"``, ``"project"``}
+                Specifies handling residual branch and conv branch channel mismatches. Defaults to ``"pad"``.
+
+                - ``"pad"``: with zero padding.
+                - ``"project"``: with a trainable conv with kernel size one.
+        """
+        super().__init__()
+        self.project = None
+        self.pad = None
+        if in_channels == out_channels:
+            return
+        mode = look_up_option(mode, ChannelMatching)
+        if mode == ChannelMatching.PROJECT:
+            conv_type = Conv[Conv.CONV, spatial_dims]
+            self.project = conv_type(in_channels, out_channels, kernel_size=1)
+            return
+        if mode == ChannelMatching.PAD:
+            if in_channels > out_channels:
+                raise ValueError('Incompatible values: channel_matching="pad" and in_channels > out_channels.')
+            pad_1 = (out_channels - in_channels) // 2
+            pad_2 = out_channels - in_channels - pad_1
+            pad = [0, 0] * spatial_dims + [pad_1, pad_2] + [0, 0]
+            self.pad = tuple(pad)
+            return
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.project is not None:
+            return torch.as_tensor(self.project(x))  # as_tensor used to get around mypy typing bug
+        if self.pad is not None:
+            return F.pad(x, self.pad)
+        return x
+
+
+class SkipConnection(nn.Module):
+    """
+    Combine the forward pass input with the result from the given submodule::
+
+        --+--submodule--o--
+          |_____________|
+
+    The available modes are ``"cat"``, ``"add"``, ``"mul"``.
+    """
+
+    def __init__(self, submodule, dim: int = 1, mode: Union[str, SkipMode] = "cat") -> None:
+        """
+
+        Args:
+            submodule: the module defines the trainable branch.
+            dim: the dimension over which the tensors are concatenated.
+                Used when mode is ``"cat"``.
+            mode: ``"cat"``, ``"add"``, ``"mul"``. defaults to ``"cat"``.
+        """
+        super().__init__()
+        self.submodule = submodule
+        self.dim = dim
+        self.mode = look_up_option(mode, SkipMode).value
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        y = self.submodule(x)
+
+        if self.mode == "cat":
+            return torch.cat([x, y], dim=self.dim)
+        if self.mode == "add":
+            return torch.add(x, y)
+        if self.mode == "mul":
+            return torch.mul(x, y)
+        raise NotImplementedError(f"Unsupported mode {self.mode}.")
+
+
+class Flatten(nn.Module):
+    """
+    Flattens the given input in the forward pass to be [B,-1] in shape.
+    """
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x.view(x.size(0), -1)
+
+
+class Reshape(nn.Module):
+    """
+    Reshapes input tensors to the given shape (minus batch dimension), retaining original batch size.
+    """
+
+    def __init__(self, *shape: int) -> None:
+        """
+        Given a shape list/tuple `shape` of integers (s0, s1, ... , sn), this layer will reshape input tensors of
+        shape (batch, s0 * s1 * ... * sn) to shape (batch, s0, s1, ... , sn).
+
+        Args:
+            shape: list/tuple of integer shape dimensions
+        """
+        super().__init__()
+        self.shape = (1,) + tuple(shape)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        shape = list(self.shape)
+        shape[0] = x.shape[0]  # done this way for Torchscript
+        return x.reshape(shape)
+
+
+def _separable_filtering_conv(
+    input_: torch.Tensor,
+    kernels: List[torch.Tensor],
+    pad_mode: str,
+    d: int,
+    spatial_dims: int,
+    paddings: List[int],
+    num_channels: int,
+) -> torch.Tensor:
+
+    if d < 0:
+        return input_
+
+    s = [1] * len(input_.shape)
+    s[d + 2] = -1
+    _kernel = kernels[d].reshape(s)
+
+    # if filter kernel is unity, don't convolve
+    if _kernel.numel() == 1 and _kernel[0] == 1:
+        return _separable_filtering_conv(input_, kernels, pad_mode, d - 1, spatial_dims, paddings, num_channels)
+
+    _kernel = _kernel.repeat([num_channels, 1] + [1] * spatial_dims)
+    _padding = [0] * spatial_dims
+    _padding[d] = paddings[d]
+    conv_type = [F.conv1d, F.conv2d, F.conv3d][spatial_dims - 1]
+
+    # translate padding for input to torch.nn.functional.pad
+    _reversed_padding_repeated_twice: List[List[int]] = [[p, p] for p in reversed(_padding)]
+    _sum_reversed_padding_repeated_twice: List[int] = sum(_reversed_padding_repeated_twice, [])
+    padded_input = F.pad(input_, _sum_reversed_padding_repeated_twice, mode=pad_mode)
+
+    return conv_type(
+        input=_separable_filtering_conv(padded_input, kernels, pad_mode, d - 1, spatial_dims, paddings, num_channels),
+        weight=_kernel,
+        groups=num_channels,
+    )
+
+
+def separable_filtering(x: torch.Tensor, kernels: List[torch.Tensor], mode: str = "zeros") -> torch.Tensor:
+    """
+    Apply 1-D convolutions along each spatial dimension of `x`.
+
+    Args:
+        x: the input image. must have shape (batch, channels, H[, W, ...]).
+        kernels: kernel along each spatial dimension.
+            could be a single kernel (duplicated for all spatial dimensions), or
+            a list of `spatial_dims` number of kernels.
+        mode (string, optional): padding mode passed to convolution class. ``'zeros'``, ``'reflect'``, ``'replicate'``
+            or ``'circular'``. Default: ``'zeros'``. See ``torch.nn.Conv1d()`` for more information.
+
+    Raises:
+        TypeError: When ``x`` is not a ``torch.Tensor``.
+
+    Examples:
+
+    .. code-block:: python
+
+        >>> 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.))])
+
+    """
+
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"x must be a torch.Tensor but is {type(x).__name__}.")
+
+    spatial_dims = len(x.shape) - 2
+    if isinstance(kernels, torch.Tensor):
+        kernels = [kernels] * spatial_dims
+    _kernels = [s.to(x) for s in kernels]
+    _paddings = [(k.shape[0] - 1) // 2 for k in _kernels]
+    n_chs = x.shape[1]
+    pad_mode = "constant" if mode == "zeros" else mode
+
+    return _separable_filtering_conv(x, _kernels, pad_mode, spatial_dims - 1, spatial_dims, _paddings, n_chs)
+
+
+def apply_filter(x: torch.Tensor, kernel: torch.Tensor, **kwargs) -> torch.Tensor:
+    """
+    Filtering `x` with `kernel` independently for each batch and channel respectively.
+
+    Args:
+        x: the input image, must have shape (batch, channels, H[, W, D]).
+        kernel: `kernel` must at least have the spatial shape (H_k[, W_k, D_k]).
+            `kernel` shape must be broadcastable to the `batch` and `channels` dimensions of `x`.
+        kwargs: keyword arguments passed to `conv*d()` functions.
+
+    Returns:
+        The filtered `x`.
+
+    Examples:
+
+    .. code-block:: python
+
+        >>> 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
+
+    """
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"x must be a torch.Tensor but is {type(x).__name__}.")
+    batch, chns, *spatials = x.shape
+    n_spatial = len(spatials)
+    if n_spatial > 3:
+        raise NotImplementedError(f"Only spatial dimensions up to 3 are supported but got {n_spatial}.")
+    k_size = len(kernel.shape)
+    if k_size < n_spatial or k_size > n_spatial + 2:
+        raise ValueError(
+            f"kernel must have {n_spatial} ~ {n_spatial + 2} dimensions to match the input shape {x.shape}."
+        )
+    kernel = kernel.to(x)
+    # broadcast kernel size to (batch chns, spatial_kernel_size)
+    kernel = kernel.expand(batch, chns, *kernel.shape[(k_size - n_spatial) :])
+    kernel = kernel.reshape(-1, 1, *kernel.shape[2:])  # group=1
+    x = x.view(1, kernel.shape[0], *spatials)
+    conv = [F.conv1d, F.conv2d, F.conv3d][n_spatial - 1]
+    if "padding" not in kwargs:
+        if pytorch_after(1, 10):
+            kwargs["padding"] = "same"
+        else:
+            # even-sized kernels are not supported
+            kwargs["padding"] = [(k - 1) // 2 for k in kernel.shape[2:]]
+
+    if "stride" not in kwargs:
+        kwargs["stride"] = 1
+    output = conv(x, kernel, groups=kernel.shape[0], bias=None, **kwargs)
+    return output.view(batch, chns, *output.shape[2:])
+
+
+class SavitzkyGolayFilter(nn.Module):
+    """
+    Convolve a Tensor along a particular axis with a Savitzky-Golay kernel.
+
+    Args:
+        window_length: Length of the filter window, must be a positive odd integer.
+        order: Order of the polynomial to fit to each window, must be less than ``window_length``.
+        axis (optional): Axis along which to apply the filter kernel. Default 2 (first spatial dimension).
+        mode (string, optional): padding mode passed to convolution class. ``'zeros'``, ``'reflect'``, ``'replicate'`` or
+        ``'circular'``. Default: ``'zeros'``. See torch.nn.Conv1d() for more information.
+    """
+
+    def __init__(self, window_length: int, order: int, axis: int = 2, mode: str = "zeros"):
+
+        super().__init__()
+        if order >= window_length:
+            raise ValueError("order must be less than window_length.")
+
+        self.axis = axis
+        self.mode = mode
+        self.coeffs = self._make_coeffs(window_length, order)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: Tensor or array-like to filter. Must be real, in shape ``[Batch, chns, spatial1, spatial2, ...]`` and
+                have a device type of ``'cpu'``.
+        Returns:
+            torch.Tensor: ``x`` filtered by Savitzky-Golay kernel with window length ``self.window_length`` using
+            polynomials of order ``self.order``, along axis specified in ``self.axis``.
+        """
+
+        # Make input a real tensor on the CPU
+        x = torch.as_tensor(x, device=x.device if isinstance(x, torch.Tensor) else None)
+        if torch.is_complex(x):
+            raise ValueError("x must be real.")
+        x = x.to(dtype=torch.float)
+
+        if (self.axis < 0) or (self.axis > len(x.shape) - 1):
+            raise ValueError(f"Invalid axis for shape of x, got axis {self.axis} and shape {x.shape}.")
+
+        # Create list of filter kernels (1 per spatial dimension). The kernel for self.axis will be the savgol coeffs,
+        # while the other kernels will be set to [1].
+        n_spatial_dims = len(x.shape) - 2
+        spatial_processing_axis = self.axis - 2
+        new_dims_before = spatial_processing_axis
+        new_dims_after = n_spatial_dims - spatial_processing_axis - 1
+        kernel_list = [self.coeffs.to(device=x.device, dtype=x.dtype)]
+        for _ in range(new_dims_before):
+            kernel_list.insert(0, torch.ones(1, device=x.device, dtype=x.dtype))
+        for _ in range(new_dims_after):
+            kernel_list.append(torch.ones(1, device=x.device, dtype=x.dtype))
+
+        return separable_filtering(x, kernel_list, mode=self.mode)
+
+    @staticmethod
+    def _make_coeffs(window_length, order):
+
+        half_length, rem = divmod(window_length, 2)
+        if rem == 0:
+            raise ValueError("window_length must be odd.")
+
+        idx = torch.arange(window_length - half_length - 1, -half_length - 1, -1, dtype=torch.float, device="cpu")
+        a = idx ** torch.arange(order + 1, dtype=torch.float, device="cpu").reshape(-1, 1)
+        y = torch.zeros(order + 1, dtype=torch.float, device="cpu")
+        y[0] = 1.0
+        return torch.lstsq(y, a).solution.squeeze()
+
+
+class HilbertTransform(nn.Module):
+    """
+    Determine the analytical signal of a Tensor along a particular axis.
+
+    Args:
+        axis: Axis along which to apply Hilbert transform. Default 2 (first spatial dimension).
+        n: Number of Fourier components (i.e. FFT size). Default: ``x.shape[axis]``.
+    """
+
+    def __init__(self, axis: int = 2, n: Union[int, None] = None) -> None:
+
+        super().__init__()
+        self.axis = axis
+        self.n = n
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: Tensor or array-like to transform. Must be real and in shape ``[Batch, chns, spatial1, spatial2, ...]``.
+        Returns:
+            torch.Tensor: Analytical signal of ``x``, transformed along axis specified in ``self.axis`` using
+            FFT of size ``self.N``. The absolute value of ``x_ht`` relates to the envelope of ``x`` along axis ``self.axis``.
+        """
+
+        # Make input a real tensor
+        x = torch.as_tensor(x, device=x.device if isinstance(x, torch.Tensor) else None)
+        if torch.is_complex(x):
+            raise ValueError("x must be real.")
+        x = x.to(dtype=torch.float)
+
+        if (self.axis < 0) or (self.axis > len(x.shape) - 1):
+            raise ValueError(f"Invalid axis for shape of x, got axis {self.axis} and shape {x.shape}.")
+
+        n = x.shape[self.axis] if self.n is None else self.n
+        if n <= 0:
+            raise ValueError("N must be positive.")
+        x = torch.as_tensor(x, dtype=torch.complex64)
+        # Create frequency axis
+        f = torch.cat(
+            [
+                torch.true_divide(torch.arange(0, (n - 1) // 2 + 1, device=x.device), float(n)),
+                torch.true_divide(torch.arange(-(n // 2), 0, device=x.device), float(n)),
+            ]
+        )
+        xf = fft.fft(x, n=n, dim=self.axis)
+        # Create step function
+        u = torch.heaviside(f, torch.tensor([0.5], device=f.device))
+        u = torch.as_tensor(u, dtype=x.dtype, device=u.device)
+        new_dims_before = self.axis
+        new_dims_after = len(xf.shape) - self.axis - 1
+        for _ in range(new_dims_before):
+            u.unsqueeze_(0)
+        for _ in range(new_dims_after):
+            u.unsqueeze_(-1)
+
+        ht = fft.ifft(xf * 2 * u, dim=self.axis)
+
+        # Apply transform
+        return torch.as_tensor(ht, device=ht.device, dtype=ht.dtype)
+
+
+class GaussianFilter(nn.Module):
+    def __init__(
+        self,
+        spatial_dims: int,
+        sigma: Union[Sequence[float], float, Sequence[torch.Tensor], torch.Tensor],
+        truncated: float = 4.0,
+        approx: str = "erf",
+        requires_grad: bool = False,
+    ) -> None:
+        """
+        Args:
+            spatial_dims: number of spatial dimensions of the input image.
+                must have shape (Batch, channels, H[, W, ...]).
+            sigma: std. could be a single value, or `spatial_dims` number of values.
+            truncated: spreads how many stds.
+            approx: discrete Gaussian kernel type, available options are "erf", "sampled", and "scalespace".
+
+                - ``erf`` approximation interpolates the error function;
+                - ``sampled`` uses a sampled Gaussian kernel;
+                - ``scalespace`` corresponds to
+                  https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel
+                  based on the modified Bessel functions.
+
+            requires_grad: whether to store the gradients for sigma.
+                if True, `sigma` will be the initial value of the parameters of this module
+                (for example `parameters()` iterator could be used to get the parameters);
+                otherwise this module will fix the kernels using `sigma` as the std.
+        """
+        if issequenceiterable(sigma):
+            if len(sigma) != spatial_dims:  # type: ignore
+                raise ValueError
+        else:
+            sigma = [deepcopy(sigma) for _ in range(spatial_dims)]  # type: ignore
+        super().__init__()
+        self.sigma = [
+            torch.nn.Parameter(
+                torch.as_tensor(s, dtype=torch.float, device=s.device if isinstance(s, torch.Tensor) else None),
+                requires_grad=requires_grad,
+            )
+            for s in sigma  # type: ignore
+        ]
+        self.truncated = truncated
+        self.approx = approx
+        for idx, param in enumerate(self.sigma):
+            self.register_parameter(f"kernel_sigma_{idx}", param)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: in shape [Batch, chns, H, W, D].
+        """
+        _kernel = [gaussian_1d(s, truncated=self.truncated, approx=self.approx) for s in self.sigma]
+        return separable_filtering(x=x, kernels=_kernel)
+
+
+class LLTMFunction(Function):
+    @staticmethod
+    def forward(ctx, input, weights, bias, old_h, old_cell):
+        outputs = _C.lltm_forward(input, weights, bias, old_h, old_cell)
+        new_h, new_cell = outputs[:2]
+        variables = outputs[1:] + [weights]
+        ctx.save_for_backward(*variables)
+
+        return new_h, new_cell
+
+    @staticmethod
+    def backward(ctx, grad_h, grad_cell):
+        outputs = _C.lltm_backward(grad_h.contiguous(), grad_cell.contiguous(), *ctx.saved_tensors)
+        d_old_h, d_input, d_weights, d_bias, d_old_cell = outputs[:5]
+
+        return d_input, d_weights, d_bias, d_old_h, d_old_cell
+
+
+class LLTM(nn.Module):
+    """
+    This recurrent unit is similar to an LSTM, but differs in that it lacks a forget
+    gate and uses an Exponential Linear Unit (ELU) as its internal activation function.
+    Because this unit never forgets, call it LLTM, or Long-Long-Term-Memory unit.
+    It has both C++ and CUDA implementation, automatically switch according to the
+    target device where put this module to.
+
+    Args:
+        input_features: size of input feature data
+        state_size: size of the state of recurrent unit
+
+    Referring to: https://pytorch.org/tutorials/advanced/cpp_extension.html
+    """
+
+    def __init__(self, input_features: int, state_size: int):
+        super().__init__()
+        self.input_features = input_features
+        self.state_size = state_size
+        self.weights = nn.Parameter(torch.empty(3 * state_size, input_features + state_size))
+        self.bias = nn.Parameter(torch.empty(1, 3 * state_size))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        stdv = 1.0 / math.sqrt(self.state_size)
+        for weight in self.parameters():
+            weight.data.uniform_(-stdv, +stdv)
+
+    def forward(self, input, state):
+        return LLTMFunction.apply(input, self.weights, self.bias, *state)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/spatial_transforms.py

@@ -0,0 +1,564 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Sequence, Union
+
+import torch
+import torch.nn as nn
+
+from monai.networks import to_norm_affine
+from monai.utils import GridSampleMode, GridSamplePadMode, ensure_tuple, look_up_option, optional_import
+
+_C, _ = optional_import("monai._C")
+
+__all__ = ["AffineTransform", "grid_pull", "grid_push", "grid_count", "grid_grad"]
+
+
+class _GridPull(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, grid, interpolation, bound, extrapolate):
+        opt = (bound, interpolation, extrapolate)
+        output = _C.grid_pull(input, grid, *opt)
+        if input.requires_grad or grid.requires_grad:
+            ctx.opt = opt
+            ctx.save_for_backward(input, grid)
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad):
+        if not (ctx.needs_input_grad[0] or ctx.needs_input_grad[1]):
+            return None, None, None, None, None
+        var = ctx.saved_tensors
+        opt = ctx.opt
+        grads = _C.grid_pull_backward(grad, *var, *opt)
+        if ctx.needs_input_grad[0]:
+            return grads[0], grads[1] if ctx.needs_input_grad[1] else None, None, None, None
+        if ctx.needs_input_grad[1]:
+            return None, grads[0], None, None, None
+
+
+def grid_pull(
+    input: torch.Tensor, grid: torch.Tensor, interpolation="linear", bound="zero", extrapolate: bool = True
+) -> torch.Tensor:
+    """
+    Sample an image with respect to a deformation field.
+
+    `interpolation` can be an int, a string or an InterpolationType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific interpolation orders.
+
+    `bound` can be an int, a string or a BoundType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific boundary conditions.
+    `sliding` is a specific condition than only applies to flow fields
+    (with as many channels as dimensions). It cannot be dimension-specific.
+    Note that:
+
+        - `dft` corresponds to circular padding
+        - `dct2` corresponds to Neumann boundary conditions (symmetric)
+        - `dst2` corresponds to Dirichlet boundary conditions (antisymmetric)
+
+    See Also:
+        - https://en.wikipedia.org/wiki/Discrete_cosine_transform
+        - https://en.wikipedia.org/wiki/Discrete_sine_transform
+        - ``help(monai._C.BoundType)``
+        - ``help(monai._C.InterpolationType)``
+
+    Args:
+        input: Input image. `(B, C, Wi, Hi, Di)`.
+        grid: Deformation field. `(B, Wo, Ho, Do, 1|2|3)`.
+        interpolation (int or list[int] , optional): Interpolation order.
+            Defaults to `'linear'`.
+        bound (BoundType, or list[BoundType], optional): Boundary conditions.
+            Defaults to `'zero'`.
+        extrapolate: Extrapolate out-of-bound data.
+            Defaults to `True`.
+
+    Returns:
+        output (torch.Tensor): Deformed image `(B, C, Wo, Ho, Do)`.
+
+    """
+    # Convert parameters
+    bound = [_C.BoundType.__members__[b] if isinstance(b, str) else _C.BoundType(b) for b in ensure_tuple(bound)]
+    interpolation = [
+        _C.InterpolationType.__members__[i] if isinstance(i, str) else _C.InterpolationType(i)
+        for i in ensure_tuple(interpolation)
+    ]
+    out: torch.Tensor
+    out = _GridPull.apply(input, grid, interpolation, bound, extrapolate)
+    return out
+
+
+class _GridPush(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, grid, shape, interpolation, bound, extrapolate):
+        opt = (bound, interpolation, extrapolate)
+        output = _C.grid_push(input, grid, shape, *opt)
+        if input.requires_grad or grid.requires_grad:
+            ctx.opt = opt
+            ctx.save_for_backward(input, grid)
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad):
+        if not (ctx.needs_input_grad[0] or ctx.needs_input_grad[1]):
+            return None, None, None, None, None, None
+        var = ctx.saved_tensors
+        opt = ctx.opt
+        grads = _C.grid_push_backward(grad, *var, *opt)
+        if ctx.needs_input_grad[0]:
+            return grads[0], grads[1] if ctx.needs_input_grad[1] else None, None, None, None, None
+        if ctx.needs_input_grad[1]:
+            return None, grads[0], None, None, None, None
+
+
+def grid_push(
+    input: torch.Tensor, grid: torch.Tensor, shape=None, interpolation="linear", bound="zero", extrapolate: bool = True
+):
+    """
+    Splat an image with respect to a deformation field (pull adjoint).
+
+    `interpolation` can be an int, a string or an InterpolationType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order `[W, H, D]`,
+    to specify dimension-specific interpolation orders.
+
+    `bound` can be an int, a string or a BoundType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order `[W, H, D]`,
+    to specify dimension-specific boundary conditions.
+    `sliding` is a specific condition than only applies to flow fields
+    (with as many channels as dimensions). It cannot be dimension-specific.
+    Note that:
+
+        - `dft` corresponds to circular padding
+        - `dct2` corresponds to Neumann boundary conditions (symmetric)
+        - `dst2` corresponds to Dirichlet boundary conditions (antisymmetric)
+
+    See Also:
+
+        - https://en.wikipedia.org/wiki/Discrete_cosine_transform
+        - https://en.wikipedia.org/wiki/Discrete_sine_transform
+        - ``help(monai._C.BoundType)``
+        - ``help(monai._C.InterpolationType)``
+
+    Args:
+        input: Input image `(B, C, Wi, Hi, Di)`.
+        grid: Deformation field `(B, Wi, Hi, Di, 1|2|3)`.
+        shape: Shape of the source image.
+        interpolation (int or list[int] , optional): Interpolation order.
+            Defaults to `'linear'`.
+        bound (BoundType, or list[BoundType], optional): Boundary conditions.
+            Defaults to `'zero'`.
+        extrapolate: Extrapolate out-of-bound data.
+            Defaults to `True`.
+
+    Returns:
+        output (torch.Tensor): Splatted image `(B, C, Wo, Ho, Do)`.
+
+    """
+    # Convert parameters
+    bound = [_C.BoundType.__members__[b] if isinstance(b, str) else _C.BoundType(b) for b in ensure_tuple(bound)]
+    interpolation = [
+        _C.InterpolationType.__members__[i] if isinstance(i, str) else _C.InterpolationType(i)
+        for i in ensure_tuple(interpolation)
+    ]
+
+    if shape is None:
+        shape = tuple(input.shape[2:])
+
+    return _GridPush.apply(input, grid, shape, interpolation, bound, extrapolate)
+
+
+class _GridCount(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, grid, shape, interpolation, bound, extrapolate):
+        opt = (bound, interpolation, extrapolate)
+        output = _C.grid_count(grid, shape, *opt)
+        if grid.requires_grad:
+            ctx.opt = opt
+            ctx.save_for_backward(grid)
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad):
+        if ctx.needs_input_grad[0]:
+            var = ctx.saved_tensors
+            opt = ctx.opt
+            return _C.grid_count_backward(grad, *var, *opt), None, None, None, None
+        return None, None, None, None, None
+
+
+def grid_count(grid: torch.Tensor, shape=None, interpolation="linear", bound="zero", extrapolate: bool = True):
+    """
+    Splatting weights with respect to a deformation field (pull adjoint).
+
+    This function is equivalent to applying grid_push to an image of ones.
+
+    `interpolation` can be an int, a string or an InterpolationType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific interpolation orders.
+
+    `bound` can be an int, a string or a BoundType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific boundary conditions.
+    `sliding` is a specific condition than only applies to flow fields
+    (with as many channels as dimensions). It cannot be dimension-specific.
+    Note that:
+
+        - `dft` corresponds to circular padding
+        - `dct2` corresponds to Neumann boundary conditions (symmetric)
+        - `dst2` corresponds to Dirichlet boundary conditions (antisymmetric)
+
+    See Also:
+
+        - https://en.wikipedia.org/wiki/Discrete_cosine_transform
+        - https://en.wikipedia.org/wiki/Discrete_sine_transform
+        - ``help(monai._C.BoundType)``
+        - ``help(monai._C.InterpolationType)``
+
+    Args:
+        grid: Deformation field `(B, Wi, Hi, Di, 2|3)`.
+        shape: shape of the source image.
+        interpolation (int or list[int] , optional): Interpolation order.
+            Defaults to `'linear'`.
+        bound (BoundType, or list[BoundType], optional): Boundary conditions.
+            Defaults to `'zero'`.
+        extrapolate (bool, optional): Extrapolate out-of-bound data.
+            Defaults to `True`.
+
+    Returns:
+        output (torch.Tensor): Splat weights `(B, 1, Wo, Ho, Do)`.
+
+    """
+    # Convert parameters
+    bound = [_C.BoundType.__members__[b] if isinstance(b, str) else _C.BoundType(b) for b in ensure_tuple(bound)]
+    interpolation = [
+        _C.InterpolationType.__members__[i] if isinstance(i, str) else _C.InterpolationType(i)
+        for i in ensure_tuple(interpolation)
+    ]
+
+    if shape is None:
+        shape = tuple(grid.shape[2:])
+
+    return _GridCount.apply(grid, shape, interpolation, bound, extrapolate)
+
+
+class _GridGrad(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, grid, interpolation, bound, extrapolate):
+        opt = (bound, interpolation, extrapolate)
+        output = _C.grid_grad(input, grid, *opt)
+        if input.requires_grad or grid.requires_grad:
+            ctx.opt = opt
+            ctx.save_for_backward(input, grid)
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad):
+        if not (ctx.needs_input_grad[0] or ctx.needs_input_grad[1]):
+            return None, None, None, None, None
+        var = ctx.saved_tensors
+        opt = ctx.opt
+        grads = _C.grid_grad_backward(grad, *var, *opt)
+        if ctx.needs_input_grad[0]:
+            return grads[0], grads[1] if ctx.needs_input_grad[1] else None, None, None, None
+        if ctx.needs_input_grad[1]:
+            return None, grads[0], None, None, None
+
+
+def grid_grad(input: torch.Tensor, grid: torch.Tensor, interpolation="linear", bound="zero", extrapolate: bool = True):
+    """
+    Sample an image with respect to a deformation field.
+
+    `interpolation` can be an int, a string or an InterpolationType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific interpolation orders.
+
+    `bound` can be an int, a string or a BoundType.
+    Possible values are::
+
+        - 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
+
+    A list of values can be provided, in the order [W, H, D],
+    to specify dimension-specific boundary conditions.
+    `sliding` is a specific condition than only applies to flow fields
+    (with as many channels as dimensions). It cannot be dimension-specific.
+    Note that:
+
+        - `dft` corresponds to circular padding
+        - `dct2` corresponds to Neumann boundary conditions (symmetric)
+        - `dst2` corresponds to Dirichlet boundary conditions (antisymmetric)
+
+    See Also:
+
+        - https://en.wikipedia.org/wiki/Discrete_cosine_transform
+        - https://en.wikipedia.org/wiki/Discrete_sine_transform
+        - ``help(monai._C.BoundType)``
+        - ``help(monai._C.InterpolationType)``
+
+
+    Args:
+        input: Input image. `(B, C, Wi, Hi, Di)`.
+        grid: Deformation field. `(B, Wo, Ho, Do, 2|3)`.
+        interpolation (int or list[int] , optional): Interpolation order.
+            Defaults to `'linear'`.
+        bound (BoundType, or list[BoundType], optional): Boundary conditions.
+            Defaults to `'zero'`.
+        extrapolate: Extrapolate out-of-bound data. Defaults to `True`.
+
+    Returns:
+        output (torch.Tensor): Sampled gradients (B, C, Wo, Ho, Do, 1|2|3).
+
+    """
+    # Convert parameters
+    bound = [_C.BoundType.__members__[b] if isinstance(b, str) else _C.BoundType(b) for b in ensure_tuple(bound)]
+    interpolation = [
+        _C.InterpolationType.__members__[i] if isinstance(i, str) else _C.InterpolationType(i)
+        for i in ensure_tuple(interpolation)
+    ]
+
+    return _GridGrad.apply(input, grid, interpolation, bound, extrapolate)
+
+
+class AffineTransform(nn.Module):
+    def __init__(
+        self,
+        spatial_size: Optional[Union[Sequence[int], int]] = None,
+        normalized: bool = False,
+        mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,
+        padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.ZEROS,
+        align_corners: bool = False,
+        reverse_indexing: bool = True,
+        zero_centered: Optional[bool] = None,
+    ) -> None:
+        """
+        Apply affine transformations with a batch of affine matrices.
+
+        When `normalized=False` and `reverse_indexing=True`,
+        it does the commonly used resampling in the 'pull' direction
+        following the ``scipy.ndimage.affine_transform`` convention.
+        In this case `theta` is equivalent to (ndim+1, ndim+1) input ``matrix`` of ``scipy.ndimage.affine_transform``,
+        operates on homogeneous coordinates.
+        See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.affine_transform.html
+
+        When `normalized=True` and `reverse_indexing=False`,
+        it applies `theta` to the normalized coordinates (coords. in the range of [-1, 1]) directly.
+        This is often used with `align_corners=False` to achieve resolution-agnostic resampling,
+        thus useful as a part of trainable modules such as the spatial transformer networks.
+        See also: https://pytorch.org/tutorials/intermediate/spatial_transformer_tutorial.html
+
+        Args:
+            spatial_size: output spatial shape, the full output shape will be
+                `[N, C, *spatial_size]` where N and C are inferred from the `src` input of `self.forward`.
+            normalized: indicating whether the provided affine matrix `theta` is defined
+                for the normalized coordinates. If `normalized=False`, `theta` will be converted
+                to operate on normalized coordinates as pytorch affine_grid works with the normalized
+                coordinates.
+            mode: {``"bilinear"``, ``"nearest"``}
+                Interpolation mode to calculate output values. Defaults to ``"bilinear"``.
+                See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html
+            padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}
+                Padding mode for outside grid values. Defaults to ``"zeros"``.
+                See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html
+            align_corners: see also https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html.
+            reverse_indexing: whether to reverse the spatial indexing of image and coordinates.
+                set to `False` if `theta` follows pytorch's default "D, H, W" convention.
+                set to `True` if `theta` follows `scipy.ndimage` default "i, j, k" convention.
+            zero_centered: whether the affine is applied to coordinates in a zero-centered value range.
+                With `zero_centered=True`, for example, the center of rotation will be the
+                spatial center of the input; with `zero_centered=False`, the center of rotation will be the
+                origin of the input. This option is only available when `normalized=False`,
+                where the default behaviour is `False` if unspecified.
+                See also: :py:func:`monai.networks.utils.normalize_transform`.
+        """
+        super().__init__()
+        self.spatial_size = ensure_tuple(spatial_size) if spatial_size is not None else None
+        self.normalized = normalized
+        self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)
+        self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)
+        self.align_corners = align_corners
+        self.reverse_indexing = reverse_indexing
+        if zero_centered is not None and self.normalized:
+            raise ValueError("`normalized=True` is not compatible with the `zero_centered` option.")
+        self.zero_centered = zero_centered if zero_centered is not None else False
+
+    def forward(
+        self, src: torch.Tensor, theta: torch.Tensor, spatial_size: Optional[Union[Sequence[int], int]] = None
+    ) -> torch.Tensor:
+        """
+        ``theta`` must be an affine transformation matrix with shape
+        3x3 or Nx3x3 or Nx2x3 or 2x3 for spatial 2D transforms,
+        4x4 or Nx4x4 or Nx3x4 or 3x4 for spatial 3D transforms,
+        where `N` is the batch size. `theta` will be converted into float Tensor for the computation.
+
+        Args:
+            src (array_like): image in spatial 2D or 3D (N, C, spatial_dims),
+                where N is the batch dim, C is the number of channels.
+            theta (array_like): Nx3x3, Nx2x3, 3x3, 2x3 for spatial 2D inputs,
+                Nx4x4, Nx3x4, 3x4, 4x4 for spatial 3D inputs. When the batch dimension is omitted,
+                `theta` will be repeated N times, N is the batch dim of `src`.
+            spatial_size: output spatial shape, the full output shape will be
+                `[N, C, *spatial_size]` where N and C are inferred from the `src`.
+
+        Raises:
+            TypeError: When ``theta`` is not a ``torch.Tensor``.
+            ValueError: When ``theta`` is not one of [Nxdxd, dxd].
+            ValueError: When ``theta`` is not one of [Nx3x3, Nx4x4].
+            TypeError: When ``src`` is not a ``torch.Tensor``.
+            ValueError: When ``src`` spatially is not one of [2D, 3D].
+            ValueError: When affine and image batch dimension differ.
+
+        """
+        # validate `theta`
+        if not isinstance(theta, torch.Tensor):
+            raise TypeError(f"theta must be torch.Tensor but is {type(theta).__name__}.")
+        if theta.dim() not in (2, 3):
+            raise ValueError(f"theta must be Nxdxd or dxd, got {theta.shape}.")
+        if theta.dim() == 2:
+            theta = theta[None]  # adds a batch dim.
+        theta = theta.clone()  # no in-place change of theta
+        theta_shape = tuple(theta.shape[1:])
+        if theta_shape in ((2, 3), (3, 4)):  # needs padding to dxd
+            pad_affine = torch.tensor([0, 0, 1] if theta_shape[0] == 2 else [0, 0, 0, 1])
+            pad_affine = pad_affine.repeat(theta.shape[0], 1, 1).to(theta)
+            pad_affine.requires_grad = False
+            theta = torch.cat([theta, pad_affine], dim=1)
+        if tuple(theta.shape[1:]) not in ((3, 3), (4, 4)):
+            raise ValueError(f"theta must be Nx3x3 or Nx4x4, got {theta.shape}.")
+
+        # validate `src`
+        if not isinstance(src, torch.Tensor):
+            raise TypeError(f"src must be torch.Tensor but is {type(src).__name__}.")
+        sr = src.dim() - 2  # input spatial rank
+        if sr not in (2, 3):
+            raise ValueError(f"Unsupported src dimension: {sr}, available options are [2, 3].")
+
+        # set output shape
+        src_size = tuple(src.shape)
+        dst_size = src_size  # default to the src shape
+        if self.spatial_size is not None:
+            dst_size = src_size[:2] + self.spatial_size
+        if spatial_size is not None:
+            dst_size = src_size[:2] + ensure_tuple(spatial_size)
+
+        # reverse and normalize theta if needed
+        if not self.normalized:
+            theta = to_norm_affine(
+                affine=theta,
+                src_size=src_size[2:],
+                dst_size=dst_size[2:],
+                align_corners=self.align_corners,
+                zero_centered=self.zero_centered,
+            )
+        if self.reverse_indexing:
+            rev_idx = torch.as_tensor(range(sr - 1, -1, -1), device=src.device)
+            theta[:, :sr] = theta[:, rev_idx]
+            theta[:, :, :sr] = theta[:, :, rev_idx]
+        if (theta.shape[0] == 1) and src_size[0] > 1:
+            # adds a batch dim to `theta` in order to match `src`
+            theta = theta.repeat(src_size[0], 1, 1)
+        if theta.shape[0] != src_size[0]:
+            raise ValueError(
+                f"affine and image batch dimension must match, got affine={theta.shape[0]} image={src_size[0]}."
+            )
+
+        grid = nn.functional.affine_grid(theta=theta[:, :sr], size=list(dst_size), align_corners=self.align_corners)
+        dst = nn.functional.grid_sample(
+            input=src.contiguous(),
+            grid=grid,
+            mode=self.mode.value,
+            padding_mode=self.padding_mode.value,
+            align_corners=self.align_corners,
+        )
+        return dst

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/utils.py

@@ -0,0 +1,116 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Tuple, Union
+
+from monai.networks.layers.factories import Act, Dropout, Norm, Pool, split_args
+from monai.utils import has_option
+
+__all__ = ["get_norm_layer", "get_act_layer", "get_dropout_layer", "get_pool_layer"]
+
+
+def get_norm_layer(name: Union[Tuple, str], spatial_dims: Optional[int] = 1, channels: Optional[int] = 1):
+    """
+    Create a normalization layer instance.
+
+    For example, to create normalization layers:
+
+    .. code-block:: python
+
+        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)
+
+    Args:
+        name: a normalization type string or a tuple of type string and parameters.
+        spatial_dims: number of spatial dimensions of the input.
+        channels: number of features/channels when the normalization layer requires this parameter
+            but it is not specified in the norm parameters.
+    """
+    norm_name, norm_args = split_args(name)
+    norm_type = Norm[norm_name, spatial_dims]
+    kw_args = dict(norm_args)
+    if has_option(norm_type, "num_features") and "num_features" not in kw_args:
+        kw_args["num_features"] = channels
+    if has_option(norm_type, "num_channels") and "num_channels" not in kw_args:
+        kw_args["num_channels"] = channels
+    return norm_type(**kw_args)
+
+
+def get_act_layer(name: Union[Tuple, str]):
+    """
+    Create an activation layer instance.
+
+    For example, to create activation layers:
+
+    .. code-block:: python
+
+        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}))
+
+    Args:
+        name: an activation type string or a tuple of type string and parameters.
+    """
+    act_name, act_args = split_args(name)
+    act_type = Act[act_name]
+    return act_type(**act_args)
+
+
+def get_dropout_layer(name: Union[Tuple, str, float, int], dropout_dim: Optional[int] = 1):
+    """
+    Create a dropout layer instance.
+
+    For example, to create dropout layers:
+
+    .. code-block:: python
+
+        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}))
+
+    Args:
+        name: a dropout ratio or a tuple of dropout type and parameters.
+        dropout_dim: the spatial dimension of the dropout operation.
+    """
+    if isinstance(name, (int, float)):
+        # if dropout was specified simply as a p value, use default name and make a keyword map with the value
+        drop_name = Dropout.DROPOUT
+        drop_args = {"p": float(name)}
+    else:
+        drop_name, drop_args = split_args(name)
+    drop_type = Dropout[drop_name, dropout_dim]
+    return drop_type(**drop_args)
+
+
+def get_pool_layer(name: Union[Tuple, str], spatial_dims: Optional[int] = 1):
+    """
+    Create a pooling layer instance.
+
+    For example, to create adaptiveavg layer:
+
+    .. code-block:: python
+
+        from monai.networks.layers import get_pool_layer
+
+        pool_layer = get_pool_layer(("adaptiveavg", {"output_size": (1, 1, 1)}), spatial_dims=3)
+
+    Args:
+        name: a pooling type string or a tuple of type string and parameters.
+        spatial_dims: number of spatial dimensions of the input.
+
+    """
+    pool_name, pool_args = split_args(name)
+    pool_type = Pool[pool_name, spatial_dims]
+    return pool_type(**pool_args)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/layers/weight_init.py

@@ -0,0 +1,64 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+import torch
+
+
+def _no_grad_trunc_normal_(tensor, mean, std, a, b):
+    """Tensor initialization with truncated normal distribution.
+    Based on:
+    https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
+    https://github.com/rwightman/pytorch-image-models
+
+    Args:
+       tensor: an n-dimensional `torch.Tensor`.
+       mean: the mean of the normal distribution.
+       std: the standard deviation of the normal distribution.
+       a: the minimum cutoff value.
+       b: the maximum cutoff value.
+    """
+
+    def norm_cdf(x):
+        return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
+
+    with torch.no_grad():
+        l = norm_cdf((a - mean) / std)
+        u = norm_cdf((b - mean) / std)
+        tensor.uniform_(2 * l - 1, 2 * u - 1)
+        tensor.erfinv_()
+        tensor.mul_(std * math.sqrt(2.0))
+        tensor.add_(mean)
+        tensor.clamp_(min=a, max=b)
+        return tensor
+
+
+def trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0):
+    """Tensor initialization with truncated normal distribution.
+    Based on:
+    https://github.com/rwightman/pytorch-image-models
+
+    Args:
+       tensor: an n-dimensional `torch.Tensor`
+       mean: the mean of the normal distribution
+       std: the standard deviation of the normal distribution
+       a: the minimum cutoff value
+       b: the maximum cutoff value
+    """
+
+    if not std > 0:
+        raise ValueError("the standard deviation should be greater than zero.")
+
+    if a >= b:
+        raise ValueError("minimum cutoff value (a) should be smaller than maximum cutoff value (b).")
+
+    return _no_grad_trunc_normal_(tensor, mean, std, a, b)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/networks/nets/__init__.py

@@ -0,0 +1,91 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .ahnet import AHnet, Ahnet, AHNet
+from .attentionunet import AttentionUnet
+from .autoencoder import AutoEncoder
+from .basic_unet import BasicUNet, BasicUnet, Basicunet, basicunet
+from .classifier import Classifier, Critic, Discriminator
+from .densenet import (
+    DenseNet,
+    Densenet,
+    DenseNet121,
+    Densenet121,
+    DenseNet169,
+    Densenet169,
+    DenseNet201,
+    Densenet201,
+    DenseNet264,
+    Densenet264,
+    densenet121,
+    densenet169,
+    densenet201,
+    densenet264,
+)
+from .dints import DiNTS, TopologyConstruction, TopologyInstance, TopologySearch
+from .dynunet import DynUNet, DynUnet, Dynunet
+from .efficientnet import (
+    BlockArgs,
+    EfficientNet,
+    EfficientNetBN,
+    EfficientNetBNFeatures,
+    drop_connect,
+    get_efficientnet_image_size,
+)
+from .fullyconnectednet import FullyConnectedNet, VarFullyConnectedNet
+from .generator import Generator
+from .highresnet import HighResBlock, HighResNet
+from .milmodel import MILModel
+from .netadapter import NetAdapter
+from .regressor import Regressor
+from .regunet import GlobalNet, LocalNet, RegUNet
+from .resnet import ResNet, resnet10, resnet18, resnet34, resnet50, resnet101, resnet152, resnet200
+from .segresnet import SegResNet, SegResNetVAE
+from .senet import (
+    SENet,
+    SEnet,
+    Senet,
+    SENet154,
+    SEnet154,
+    Senet154,
+    SEResNet50,
+    SEresnet50,
+    Seresnet50,
+    SEResNet101,
+    SEresnet101,
+    Seresnet101,
+    SEResNet152,
+    SEresnet152,
+    Seresnet152,
+    SEResNext50,
+    SEResNeXt50,
+    SEresnext50,
+    Seresnext50,
+    SEResNext101,
+    SEResNeXt101,
+    SEresnext101,
+    Seresnext101,
+    senet154,
+    seresnet50,
+    seresnet101,
+    seresnet152,
+    seresnext50,
+    seresnext101,
+)
+from .swin_unetr import SwinUNETR
+from .torchvision_fc import TorchVisionFCModel
+from .transchex import BertAttention, BertMixedLayer, BertOutput, BertPreTrainedModel, MultiModal, Pooler, Transchex
+from .unet import UNet, Unet
+from .unetr import UNETR
+from .varautoencoder import VarAutoEncoder
+from .vit import ViT
+from .vitautoenc import ViTAutoEnc
+from .vnet import VNet