|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
from __future__ import annotations |
|
|
|
|
|
from typing import Sequence |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
|
|
|
from monai.networks.blocks import Convolution, ResidualUnit |
|
|
from monai.networks.layers.factories import Act, Norm |
|
|
|
|
|
__ALL__ = ["DenseBlock", "ConvDenseBlock"] |
|
|
|
|
|
|
|
|
class DenseBlock(nn.Sequential): |
|
|
""" |
|
|
A DenseBlock is a sequence of layers where each layer's outputs are concatenated with their inputs. This has the |
|
|
effect of accumulating outputs from previous layers as inputs to later ones and as the final output of the block. |
|
|
|
|
|
Args: |
|
|
layers: sequence of nn.Module objects to define the individual layers of the dense block |
|
|
""" |
|
|
|
|
|
def __init__(self, layers: Sequence[nn.Module]): |
|
|
super().__init__() |
|
|
for i, l in enumerate(layers): |
|
|
self.add_module(f"layers{i}", l) |
|
|
|
|
|
def forward(self, x): |
|
|
for l in self.children(): |
|
|
result = l(x) |
|
|
x = torch.cat([x, result], 1) |
|
|
|
|
|
return x |
|
|
|
|
|
|
|
|
class ConvDenseBlock(DenseBlock): |
|
|
""" |
|
|
This dense block is defined as a sequence of `Convolution` or `ResidualUnit` blocks. The `_get_layer` method returns |
|
|
an object for each layer and can be overridden to change the composition of the block. |
|
|
|
|
|
Args: |
|
|
spatial_dims: number of spatial dimensions. |
|
|
in_channels: number of input channels. |
|
|
channels: output channels for each layer. |
|
|
dilations: dilation value for each layer. |
|
|
kernel_size: convolution kernel size. Defaults to 3. |
|
|
num_res_units: number of convolutions. Defaults to 2. |
|
|
adn_ordering: a string representing the ordering of activation, normalization, and dropout. Defaults to "NDA". |
|
|
act: activation type and arguments. Defaults to PReLU. |
|
|
norm: feature normalization type and arguments. Defaults to instance norm. |
|
|
dropout: dropout ratio. Defaults to no dropout. |
|
|
bias: whether to have a bias term. Defaults to True. |
|
|
""" |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
spatial_dims: int, |
|
|
in_channels: int, |
|
|
channels: Sequence[int], |
|
|
dilations: Sequence[int] | None = None, |
|
|
kernel_size: Sequence[int] | int = 3, |
|
|
num_res_units: int = 0, |
|
|
adn_ordering: str = "NDA", |
|
|
act: tuple | str | None = Act.PRELU, |
|
|
norm: tuple | str | None = Norm.INSTANCE, |
|
|
dropout: tuple | str | float | None = None, |
|
|
bias: bool = True, |
|
|
): |
|
|
self.spatial_dims = spatial_dims |
|
|
self.kernel_size = kernel_size |
|
|
self.num_res_units = num_res_units |
|
|
self.adn_ordering = adn_ordering |
|
|
self.act = act |
|
|
self.norm = norm |
|
|
self.dropout = dropout |
|
|
self.bias = bias |
|
|
|
|
|
l_channels = in_channels |
|
|
dilations = dilations if dilations is not None else ([1] * len(channels)) |
|
|
layers = [] |
|
|
|
|
|
if len(channels) != len(dilations): |
|
|
raise ValueError("Length of `channels` and `dilations` must match") |
|
|
|
|
|
for c, d in zip(channels, dilations): |
|
|
layer = self._get_layer(l_channels, c, d) |
|
|
layers.append(layer) |
|
|
l_channels += c |
|
|
|
|
|
super().__init__(layers) |
|
|
|
|
|
def _get_layer(self, in_channels, out_channels, dilation): |
|
|
if self.num_res_units > 0: |
|
|
return ResidualUnit( |
|
|
spatial_dims=self.spatial_dims, |
|
|
in_channels=in_channels, |
|
|
out_channels=out_channels, |
|
|
strides=1, |
|
|
kernel_size=self.kernel_size, |
|
|
subunits=self.num_res_units, |
|
|
adn_ordering=self.adn_ordering, |
|
|
act=self.act, |
|
|
norm=self.norm, |
|
|
dropout=self.dropout, |
|
|
dilation=dilation, |
|
|
bias=self.bias, |
|
|
) |
|
|
else: |
|
|
return Convolution( |
|
|
spatial_dims=self.spatial_dims, |
|
|
in_channels=in_channels, |
|
|
out_channels=out_channels, |
|
|
strides=1, |
|
|
kernel_size=self.kernel_size, |
|
|
act=self.act, |
|
|
norm=self.norm, |
|
|
dropout=self.dropout, |
|
|
dilation=dilation, |
|
|
bias=self.bias, |
|
|
) |
|
|
|
