def __init__(self,
use_cuda=True,
kernel_sizes=[3],
channels=[1],
symmetric_mode=True,
bn=False,
dimension=6):
super(GeometricSparseNeighConsensus, self).__init__()
self.symmetric_mode = symmetric_mode
self.kernel_sizes = kernel_sizes
self.channels = channels
num_layers = len(kernel_sizes)
nn_modules = list()
ch_in = 1
ch_out = channels[0]
k_size = kernel_sizes[0]
nn_modules.append(ME.MinkowskiReLU(inplace=True))
nn_modules.append(
ME.MinkowskiConvolution(1,
1,
kernel_size=k_size,
bias=False,
dimension=dimension))
#nn_modules.append(ME.MinkowskiConvolution(8,1,kernel_size=k_size,bias=False,dimension=dimension))
#nn_modules.append(ME.MinkowskiSigmoid())
nn_modules.append(ME.MinkowskiSigmoid())
self.conv = nn.Sequential(*nn_modules)
if use_cuda:
self.conv.cuda()
def __init__(self, channel, reduction=16, D=-1):
# Global coords does not require coords_key
super(SELayer, self).__init__()
self.fc = nn.Sequential(
ME.MinkowskiLinear(channel, channel // reduction), ME.MinkowskiReLU(inplace=True),
ME.MinkowskiLinear(channel // reduction, channel), ME.MinkowskiSigmoid())
self.pooling = ME.MinkowskiGlobalPooling(dimension=D)
self.broadcast_mul = ME.MinkowskiBroadcastMultiplication(dimension=D)
def __init__(self,
in_planes,
out_planes,
kernel_size,
stride,
with_uncertainty=False,
add_rgb=False):
super().__init__()
self.layer3 = nn.Sequential(
ME.MinkowskiConvolution(in_planes,
out_planes * 2,
kernel_size=kernel_size,
stride=1,
dimension=2),
ME.MinkowskiBatchNorm(out_planes * 2),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiConvolution(out_planes * 2,
out_planes * 2,
kernel_size=kernel_size,
stride=1,
dimension=2),
ME.MinkowskiBatchNorm(out_planes * 2),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiConvolution(out_planes * 2,
out_planes,
kernel_size=kernel_size,
stride=1,
dimension=2),
)
self.layer2 = nn.Sequential(
ME.MinkowskiConvolution(in_planes,
out_planes * 2,
kernel_size=kernel_size,
stride=1,
dimension=2),
ME.MinkowskiBatchNorm(out_planes * 2),
ME.MinkowskiReLU(inplace=True),
ME.MinkowskiConvolution(out_planes * 2,
out_planes,
kernel_size=kernel_size,
stride=1,
dimension=2),
)
self.layer1 = nn.Sequential(
ME.MinkowskiConvolution(in_planes,
out_planes,
kernel_size=kernel_size,
stride=1,
dimension=2), )
self.layer_final = nn.Sequential(ME.MinkowskiBatchNorm(out_planes),
ME.MinkowskiReLU(inplace=True))
self.pool = None if stride == 1 else ME.MinkowskiMaxPooling(
3, stride, dimension=2)
self.add_rgb = add_rgb
self.with_uncertainty = with_uncertainty
if with_uncertainty:
self.unc_layer = nn.Sequential(
ME.MinkowskiConvolution(out_planes,
1,
kernel_size=3,
stride=1,
dimension=2), ME.MinkowskiSigmoid())
