def __init__(
self,
ordering: str = "NDA",
in_channels: Optional[int] = None,
act: Optional[Union[Tuple, str]] = "RELU",
norm: Optional[Union[Tuple, str]] = None,
norm_dim: Optional[int] = None,
dropout: Optional[Union[Tuple, str, float]] = None,
dropout_dim: Optional[int] = None,
) -> None:
super().__init__()
op_dict = {"A": None, "D": None, "N": None}
# define the normalization type and the arguments to the constructor
if norm is not None:
if norm_dim is None and dropout_dim is None:
raise ValueError("norm_dim or dropout_dim needs to be specified.")
norm_name, norm_args = split_args(norm)
norm_type = Norm[norm_name, norm_dim or dropout_dim]
kw_args = dict(norm_args)
if has_option(norm_type, "num_features") and "num_features" not in kw_args:
kw_args["num_features"] = in_channels
if has_option(norm_type, "num_channels") and "num_channels" not in kw_args:
kw_args["num_channels"] = in_channels
op_dict["N"] = norm_type(**kw_args)
# define the activation type and the arguments to the constructor
if act is not None:
act_name, act_args = split_args(act)
act_type = Act[act_name]
op_dict["A"] = act_type(**act_args)
if dropout is not None:
# if dropout was specified simply as a p value, use default name and make a keyword map with the value
if isinstance(dropout, (int, float)):
drop_name = Dropout.DROPOUT
drop_args = {"p": float(dropout)}
else:
drop_name, drop_args = split_args(dropout)
if norm_dim is None and dropout_dim is None:
raise ValueError("norm_dim or dropout_dim needs to be specified.")
drop_type = Dropout[drop_name, dropout_dim or norm_dim]
op_dict["D"] = drop_type(**drop_args)
for item in ordering.upper():
if item not in op_dict:
raise ValueError(f"ordering must be a string of {op_dict}, got {item} in it.")
if op_dict[item] is not None:
self.add_module(item, op_dict[item]) # type: ignore
def __init__(
self,
spatial_dims: int,
in_channels: int,
r: int = 2,
acti_type_1: Union[Tuple[str, Dict], str] = ("relu", {
"inplace": True
}),
acti_type_2: Union[Tuple[str, Dict], str] = "sigmoid",
add_residual: bool = False,
) -> None:
"""
Args:
spatial_dims: number of spatial dimensions, could be 1, 2, or 3.
in_channels: number of input channels.
r: the reduction ratio r in the paper. Defaults to 2.
acti_type_1: activation type of the hidden squeeze layer. Defaults to ``("relu", {"inplace": True})``.
acti_type_2: activation type of the output squeeze layer. Defaults to "sigmoid".
Raises:
ValueError: When ``r`` is nonpositive or larger than ``in_channels``.
See also:
:py:class:`monai.networks.layers.Act`
"""
super(ChannelSELayer, self).__init__()
self.add_residual = add_residual
pool_type = Pool[Pool.ADAPTIVEAVG, spatial_dims]
self.avg_pool = pool_type(1) # spatial size (1, 1, ...)
channels = int(in_channels // r)
if channels <= 0:
raise ValueError(
f"r must be positive and smaller than in_channels, got r={r} in_channels={in_channels}."
)
act_1, act_1_args = split_args(acti_type_1)
act_2, act_2_args = split_args(acti_type_2)
self.fc = nn.Sequential(
nn.Linear(in_channels, channels, bias=True),
Act[act_1](**act_1_args),
nn.Linear(channels, in_channels, bias=True),
Act[act_2](**act_2_args),
)
def __init__(
self,
in_shape: Sequence[int],
classes: int,
channels: Sequence[int],
strides: Sequence[int],
kernel_size: Union[Sequence[int], int] = 3,
num_res_units: int = 2,
act=Act.PRELU,
norm=Norm.INSTANCE,
dropout: Optional[float] = None,
bias: bool = True,
last_act: Optional[str] = None,
) -> None:
"""
Args:
in_shape: tuple of integers stating the dimension of the input tensor (minus batch dimension)
classes: integer stating the dimension of the final output tensor
channels: tuple of integers stating the output channels of each convolutional layer
strides: tuple of integers stating the stride (downscale factor) of each convolutional layer
kernel_size: integer or tuple of integers stating size of convolutional kernels
num_res_units: integer stating number of convolutions in residual units, 0 means no residual units
act: name or type defining activation layers
norm: name or type defining normalization layers
dropout: optional float value in range [0, 1] stating dropout probability for layers, None for no dropout
bias: boolean stating if convolution layers should have a bias component
last_act: name defining the last activation layer
"""
super().__init__(in_shape, (classes, ), channels, strides, kernel_size,
num_res_units, act, norm, dropout, bias)
if last_act is not None:
last_act_name, last_act_args = split_args(last_act)
last_act_type = Act[last_act_name]
self.final.add_module("lastact", last_act_type(**last_act_args))
def get_acti_layer(act: Union[Tuple[str, Dict], str]):
act_name, act_args = split_args(act)
act_type = Act[act_name]
return act_type(**act_args)
def get_acti_layer(act: Union[Tuple[str, Dict], str], nchan: int = 0):
if act == "prelu":
act = ("prelu", {"num_parameters": nchan})
act_name, act_args = split_args(act)
act_type = Act[act_name]
return act_type(**act_args)
def __init__(
self,
spatial_dims: int,
in_channels: int,
n_chns_1: int,
n_chns_2: int,
n_chns_3: int,
conv_param_1: Optional[Dict] = None,
conv_param_2: Optional[Dict] = None,
conv_param_3: Optional[Dict] = None,
project: Optional[Convolution] = None,
r: int = 2,
acti_type_1: Union[Tuple[str, Dict], str] = ("relu", {
"inplace": True
}),
acti_type_2: Union[Tuple[str, Dict], str] = "sigmoid",
acti_type_final: Optional[Union[Tuple[str, Dict], str]] = ("relu", {
"inplace":
True
}),
):
"""
Args:
spatial_dims: number of spatial dimensions, could be 1, 2, or 3.
in_channels: number of input channels.
n_chns_1: number of output channels in the 1st convolution.
n_chns_2: number of output channels in the 2nd convolution.
n_chns_3: number of output channels in the 3rd convolution.
conv_param_1: additional parameters to the 1st convolution.
Defaults to ``{"kernel_size": 1, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}``
conv_param_2: additional parameters to the 2nd convolution.
Defaults to ``{"kernel_size": 3, "norm": Norm.BATCH, "act": ("relu", {"inplace": True})}``
conv_param_3: additional parameters to the 3rd convolution.
Defaults to ``{"kernel_size": 1, "norm": Norm.BATCH, "act": None}``
project: in the case of residual chns and output chns doesn't match, a project
(Conv) layer/block is used to adjust the number of chns. In SENET, it is
consisted with a Conv layer as well as a Norm layer.
Defaults to None (chns are matchable) or a Conv layer with kernel size 1.
r: the reduction ratio r in the paper. Defaults to 2.
acti_type_1: activation type of the hidden squeeze layer. Defaults to "relu".
acti_type_2: activation type of the output squeeze layer. Defaults to "sigmoid".
acti_type_final: activation type of the end of the block. Defaults to "relu".
See also:
:py:class:`monai.networks.blocks.ChannelSELayer`
"""
super(SEBlock, self).__init__()
if not conv_param_1:
conv_param_1 = {
"kernel_size": 1,
"norm": Norm.BATCH,
"act": ("relu", {
"inplace": True
})
}
self.conv1 = Convolution(dimensions=spatial_dims,
in_channels=in_channels,
out_channels=n_chns_1,
**conv_param_1)
if not conv_param_2:
conv_param_2 = {
"kernel_size": 3,
"norm": Norm.BATCH,
"act": ("relu", {
"inplace": True
})
}
self.conv2 = Convolution(dimensions=spatial_dims,
in_channels=n_chns_1,
out_channels=n_chns_2,
**conv_param_2)
if not conv_param_3:
conv_param_3 = {"kernel_size": 1, "norm": Norm.BATCH, "act": None}
self.conv3 = Convolution(dimensions=spatial_dims,
in_channels=n_chns_2,
out_channels=n_chns_3,
**conv_param_3)
self.se_layer = ChannelSELayer(spatial_dims=spatial_dims,
in_channels=n_chns_3,
r=r,
acti_type_1=acti_type_1,
acti_type_2=acti_type_2)
if project is None and in_channels != n_chns_3:
self.project = Conv[Conv.CONV, spatial_dims](in_channels,
n_chns_3,
kernel_size=1)
elif project is None:
self.project = nn.Identity()
else:
self.project = project
if acti_type_final is not None:
act_final, act_final_args = split_args(acti_type_final)
self.act = Act[act_final](**act_final_args)
else:
self.act = nn.Identity()