def __init__(self,
kernel_size,
stride=1,
dilation=1,
kernel_generator=None,
out_coords_key=None,
is_transpose=False,
average=True,
dimension=-1):
super(MinkowskiPoolingBase, self).__init__()
if out_coords_key is not None:
assert isinstance(out_coords_key, CoordsKey)
assert dimension > 0, f"dimension must be a positive integer, {dimension}"
stride = convert_to_int_tensor(stride, dimension)
kernel_size = convert_to_int_tensor(kernel_size, dimension)
dilation = convert_to_int_tensor(dilation, dimension)
if torch.prod(kernel_size) == 1 and torch.prod(stride) == 1:
raise ValueError('Trivial input output mapping')
if kernel_generator is None:
kernel_generator = KernelGenerator(kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension)
self.is_transpose = is_transpose
self.average = average
self.kernel_size = kernel_size
self.stride = stride
self.dilation = dilation
self.kernel_generator = kernel_generator
self.out_coords_key = out_coords_key
self.dimension = dimension
def __init__(self,
in_channels,
out_channels,
kernel_size=-1,
stride=1,
dilation=1,
has_bias=False,
kernel_generator=None,
out_coords_key=None,
is_transpose=False,
dimension=-1):
super(MinkowskiConvolutionBase, self).__init__()
assert dimension > 0, f"dimension must be a positive integer, {dimension}"
if out_coords_key is not None:
assert isinstance(out_coords_key, CoordsKey)
if kernel_generator is None:
kernel_generator = KernelGenerator(
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
dimension=dimension)
else:
kernel_size = kernel_generator.kernel_size
stride = convert_to_int_tensor(stride, dimension)
kernel_size = convert_to_int_tensor(kernel_size, dimension)
dilation = convert_to_int_tensor(dilation, dimension)
kernel_volume = kernel_generator.kernel_volume
self.is_transpose = is_transpose
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = kernel_size
self.kernel_volume = kernel_volume
self.stride = stride
self.dilation = dilation
self.kernel_generator = kernel_generator
self.out_coords_key = out_coords_key
self.dimension = dimension
self.use_mm = False # use matrix multiplication when kernel is 1
Tensor = torch.FloatTensor
if torch.prod(kernel_size) == 1 and torch.prod(stride) == 1:
self.kernel_shape = (self.in_channels, self.out_channels)
self.use_mm = True
else:
self.kernel_shape = (self.kernel_volume, self.in_channels,
self.out_channels)
self.kernel = Parameter(Tensor(*self.kernel_shape))
self.bias = Parameter(Tensor(1, out_channels)) if has_bias else None
self.has_bias = has_bias
def __init__(self,
in_channels,
kernel_size=-1,
stride=1,
dilation=1,
has_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:`has_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)
else:
kernel_size = kernel_generator.kernel_size
stride = convert_to_int_tensor(stride, dimension)
kernel_size = convert_to_int_tensor(kernel_size, dimension)
dilation = convert_to_int_tensor(dilation, dimension)
kernel_volume = kernel_generator.kernel_volume
self.in_channels = in_channels
self.kernel_size = kernel_size
self.kernel_volume = kernel_volume
self.stride = stride
self.dilation = dilation
self.kernel_generator = kernel_generator
self.dimension = dimension
self.use_mm = False # use matrix multiplication when kernel is 1
Tensor = torch.FloatTensor
self.kernel_shape = (self.kernel_volume, self.in_channels)
self.kernel = Parameter(Tensor(*self.kernel_shape))
self.bias = Parameter(Tensor(1, in_channels)) if has_bias else None
self.has_bias = has_bias
self.reset_parameters()
