def __init__(
self,
in_channels,
out_channels,
kernel_size=-1,
stride=1,
dilation=1,
bias=False,
kernel_generator=None,
is_transpose=False, # only the base class has this argument
expand_coordinates=False,
dimension=-1,
):
r"""
.. note::
When the kernel generator is provided, all kernel related arguments
(kernel_size, stride, dilation) will be ignored.
"""
super(MinkowskiConvolutionBase, self).__init__()
assert dimension > 0, f"dimension must be a positive integer, {dimension}"
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
expand_coordinates=expand_coordinates,
dimension=dimension,
)
else:
kernel_generator.expand_coordinates = expand_coordinates
self.is_transpose = is_transpose
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_generator = kernel_generator
self.dimension = dimension
self.use_mm = False # use matrix multiplication when kernel_volume is 1
Tensor = torch.FloatTensor
if (self.kernel_generator.kernel_volume == 1
and self.kernel_generator.requires_strided_coordinates):
kernel_shape = (self.in_channels, self.out_channels)
self.use_mm = True
else:
kernel_shape = (
self.kernel_generator.kernel_volume,
self.in_channels,
self.out_channels,
)
self.kernel = Parameter(Tensor(*kernel_shape))
self.bias = Parameter(Tensor(1, out_channels)) if bias else None
self.conv = (MinkowskiConvolutionTransposeFunction()
if is_transpose else MinkowskiConvolutionFunction())
def __init__(
self,
kernel_size,
stride=1,
dilation=1,
kernel_generator=None,
is_transpose=False,
pooling_mode=PoolingMode.LOCAL_AVG_POOLING,
dimension=-1,
):
super(MinkowskiPoolingBase, self).__init__()
assert (
dimension > 0
), f"Invalid dimension. Please provide a valid dimension argument. dimension={dimension}"
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension,
)
self.is_transpose = is_transpose
self.kernel_generator = kernel_generator
self.pooling_mode = pooling_mode
self.dimension = dimension
self.pooling = MinkowskiLocalPoolingFunction()
def __init__(
self,
kernel_size,
stride=1,
dilation=1,
kernel_generator=None,
is_transpose=False,
pooling_mode=PoolingMode.LOCAL_AVG_POOLING,
dimension=-1,
):
super(MinkowskiPoolingBase, self).__init__()
assert dimension > 0, f"dimension must be a positive integer, {dimension}"
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension,
)
self.is_transpose = is_transpose
self.kernel_generator = kernel_generator
self.pooling_mode = pooling_mode
self.dimension = dimension
self.pooling = MinkowskiLocalPoolingFunction()
def __init__(
self,
in_channels,
kernel_size=-1,
stride=1,
dilation=1,
bias=False,
kernel_generator=None,
dimension=-1,
):
r"""convolution on a sparse tensor
Args:
:attr:`in_channels` (int): the number of input channels in the
input tensor.
:attr:`kernel_size` (int, optional): the size of the kernel in the
output tensor. If not provided, :attr:`region_offset` should be
:attr:`RegionType.CUSTOM` and :attr:`region_offset` should be a 2D
matrix with size :math:`N\times D` such that it lists all :math:`N`
offsets in D-dimension.
:attr:`stride` (int, or list, optional): stride size of the
convolution layer. If non-identity is used, the output coordinates
will be at least :attr:`stride` :math:`\times` :attr:`tensor_stride`
away. When a list is given, the length must be D; each element will
be used for stride size for the specific axis.
:attr:`dilation` (int, or list, optional): dilation size for the
convolution kernel. When a list is given, the length must be D and
each element is an axis specific dilation. All elements must be > 0.
:attr:`bias` (bool, optional): if True, the convolution layer
has a bias.
:attr:`kernel_generator` (:attr:`MinkowskiEngine.KernelGenerator`,
optional): defines the custom kernel shape.
:attr:`dimension` (int): the spatial dimension of the space where
all the inputs and the network are defined. For example, images are
in a 2D space, meshes and 3D shapes are in a 3D space.
"""
super(MinkowskiChannelwiseConvolution, self).__init__()
assert dimension > 0, f"dimension must be a positive integer, {dimension}"
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension,
)
self.kernel_generator = kernel_generator
self.in_channels = in_channels
self.dimension = dimension
self.kernel_shape = (kernel_generator.kernel_volume, self.in_channels)
Tensor = torch.FloatTensor
self.kernel = Parameter(Tensor(*self.kernel_shape))
self.bias = Parameter(Tensor(1, in_channels)) if bias else None
self.reset_parameters()
def __init__(
self,
in_channels,
out_channels,
kernel_size=-1,
stride=1,
dilation=1,
bias=False,
kernel_generator=None,
convolution_mode=ConvolutionMode.DEFAULT,
dimension=None,
):
r"""a generalized sparse transposed convolution layer that creates new coordinates.
Please refer to `Generative Sparse Detection Networks for 3D Single-shot Object Detection <https://arxiv.org/abs/2006.12356>`_ for more detail. Also, please cite the following paper if you use this function.
>> @inproceedings{gwak2020gsdn,
>> title={Generative Sparse Detection Networks for 3D Single-shot Object Detection},
>> author={Gwak, JunYoung and Choy, Christopher B and Savarese, Silvio},
>> booktitle={European conference on computer vision},
>> year={2020}
>> }
Args:
:attr:`in_channels` (int): the number of input channels in the
input tensor.
:attr:`out_channels` (int): the number of output channels in the
output tensor.
:attr:`kernel_size` (int, optional): the size of the kernel in the
output tensor. If not provided, :attr:`region_offset` should be
:attr:`RegionType.CUSTOM` and :attr:`region_offset` should be a 2D
matrix with size :math:`N\times D` such that it lists all :math:`N`
offsets in D-dimension.
:attr:`stride` (int, or list, optional): stride size that defines
upsampling rate. If non-identity is used, the output coordinates
will be :attr:`tensor_stride` / :attr:`stride` apart. When a list is
given, the length must be D; each element will be used for stride
size for the specific axis.
:attr:`dilation` (int, or list, optional): dilation size for the
convolution kernel. When a list is given, the length must be D and
each element is an axis specific dilation. All elements must be > 0.
:attr:`bias` (bool, optional): if True, the convolution layer
has a bias.
:attr:`kernel_generator` (:attr:`MinkowskiEngine.KernelGenerator`,
optional): defines custom kernel shape.
:attr:`expand_coordinates` (bool, optional): Force generation of
new coordinates. When True, the output coordinates will be the
outer product of the kernel shape and the input coordinates.
`False` by defaul.
:attr:`dimension` (int): the spatial dimension of the space where
all the inputs and the network are defined. For example, images are
in a 2D space, meshes and 3D shapes are in a 3D space.
.. note:
TODO: support `kernel_size` > `stride`.
"""
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
expand_coordinates=True,
dimension=dimension,
)
else:
kernel_generator.expand_coordinates = True
MinkowskiConvolutionBase.__init__(
self,
in_channels,
out_channels,
kernel_size,
stride,
dilation,
bias,
kernel_generator,
is_transpose=True,
expand_coordinates=True,
convolution_mode=convolution_mode,
dimension=dimension,
)
self.reset_parameters(True)
def __init__(
self,
in_channels,
out_channels,
kernel_size=-1,
stride=1,
dilation=1,
bias=False,
kernel_generator=None,
expand_coordinates=False,
convolution_mode=ConvolutionMode.DEFAULT,
dimension=None,
):
r"""a generalized sparse transposed convolution layer.
Args:
:attr:`in_channels` (int): the number of input channels in the
input tensor.
:attr:`out_channels` (int): the number of output channels in the
output tensor.
:attr:`kernel_size` (int, optional): the size of the kernel in the
output tensor. If not provided, :attr:`region_offset` should be
:attr:`RegionType.CUSTOM` and :attr:`region_offset` should be a 2D
matrix with size :math:`N\times D` such that it lists all :math:`N`
offsets in D-dimension.
:attr:`stride` (int, or list, optional): stride size that defines
upsampling rate. If non-identity is used, the output coordinates
will be :attr:`tensor_stride` / :attr:`stride` apart. When a list is
given, the length must be D; each element will be used for stride
size for the specific axis.
:attr:`dilation` (int, or list, optional): dilation size for the
convolution kernel. When a list is given, the length must be D and
each element is an axis specific dilation. All elements must be > 0.
:attr:`bias` (bool, optional): if True, the convolution layer
has a bias.
:attr:`kernel_generator` (:attr:`MinkowskiEngine.KernelGenerator`,
optional): defines custom kernel shape.
:attr:`expand_coordinates` (bool, optional): Force generation of
new coordinates. When True, the output coordinates will be the
outer product of the kernel shape and the input coordinates.
`False` by default.
:attr:`dimension` (int): the spatial dimension of the space where
all the inputs and the network are defined. For example, images are
in a 2D space, meshes and 3D shapes are in a 3D space.
.. note:
TODO: support `kernel_size` > `stride`.
"""
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension,
)
MinkowskiConvolutionBase.__init__(
self,
in_channels,
out_channels,
kernel_size,
stride,
dilation,
bias,
kernel_generator,
is_transpose=True,
expand_coordinates=expand_coordinates,
convolution_mode=convolution_mode,
dimension=dimension,
)
self.reset_parameters(True)
def __init__(
self,
kernel_size,
stride,
dilation=1,
kernel_generator=None,
expand_coordinates=False,
dimension=None,
):
r"""a high-dimensional unpooling layer for sparse tensors.
Args:
:attr:`kernel_size` (int, optional): the size of the kernel in the
output tensor. If not provided, :attr:`region_offset` should be
:attr:`RegionType.CUSTOM` and :attr:`region_offset` should be a 2D
matrix with size :math:`N\times D` such that it lists all :math:`N`
offsets in D-dimension.
:attr:`stride` (int, or list, optional): stride size of the
convolution layer. If non-identity is used, the output coordinates
will be at least :attr:`stride` :math:`\times` :attr:`tensor_stride`
away. When a list is given, the length must be D; each element will
be used for stride size for the specific axis.
:attr:`dilation` (int, or list, optional): dilation size for the
convolution kernel. When a list is given, the length must be D and
each element is an axis specific dilation. All elements must be > 0.
:attr:`kernel_generator` (:attr:`MinkowskiEngine.KernelGenerator`,
optional): define custom kernel shape.
:attr:`expand_coordinates` (bool, optional): Force generation of
new coordinates. When True, the output coordinates will be the
outer product of the kernel shape and the input coordinates.
`False` by default.
:attr:`dimension` (int): the spatial dimension of the space where
all the inputs and the network are defined. For example, images are
in a 2D space, meshes and 3D shapes are in a 3D space.
"""
is_transpose = True
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
expand_coordinates=expand_coordinates,
dimension=dimension,
)
MinkowskiPoolingBase.__init__(
self,
kernel_size,
stride,
dilation,
kernel_generator,
is_transpose,
dimension=dimension,
)
self.pooling = MinkowskiLocalPoolingTransposeFunction()
