def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
bn_momentum=0.1,
D=3):
super(BasicBlockBase, self).__init__()
self.conv1 = ME.MinkowskiConvolution(inplanes,
planes,
kernel_size=3,
stride=stride,
dimension=D)
self.norm1 = get_norm(self.NORM_TYPE,
planes,
bn_momentum=bn_momentum,
D=D)
self.conv2 = ME.MinkowskiConvolution(planes,
planes,
kernel_size=3,
stride=1,
dilation=dilation,
bias=False,
dimension=D)
self.norm2 = get_norm(self.NORM_TYPE,
planes,
bn_momentum=bn_momentum,
D=D)
self.downsample = downsample
def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
bn_momentum=0.1,
region_type=0,
D=3):
super(BasicBlockBase, self).__init__()
self.conv1 = conv(inplanes,
planes,
kernel_size=3,
stride=stride,
dilation=dilation,
region_type=region_type,
dimension=D)
self.norm1 = get_norm(self.NORM_TYPE,
planes,
bn_momentum=bn_momentum,
dimension=D)
self.conv2 = conv(planes,
planes,
kernel_size=3,
stride=1,
dilation=dilation,
region_type=region_type,
dimension=D)
self.norm2 = get_norm(self.NORM_TYPE,
planes,
bn_momentum=bn_momentum,
dimension=D)
self.downsample = downsample
def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
conv_type=ConvType.HYPERCUBE,
bn_momentum=0.1,
D=3):
super(BasicBlockBase, self).__init__()
self.conv1 = conv(
inplanes, planes, kernel_size=3, stride=stride, dilation=dilation, conv_type=conv_type, D=D)
self.norm1 = get_norm(self.NORM_TYPE, planes, D, bn_momentum=bn_momentum)
self.conv2 = conv(
planes,
planes,
kernel_size=3,
stride=1,
dilation=dilation,
bias=False,
conv_type=conv_type,
D=D)
self.norm2 = get_norm(self.NORM_TYPE, planes, D, bn_momentum=bn_momentum)
self.relu = MinkowskiReLU(inplace=True)
self.downsample = downsample
def network_initialization(self, in_channels, out_channels, D):
def space_n_time_m(n, m):
return n if D == 3 else [n, n, n, m]
if D == 4:
self.OUT_PIXEL_DIST = space_n_time_m(self.OUT_PIXEL_DIST, 1)
dilations = [1, 1, 1, 1]
bn_momentum = 0.02
self.inplanes = self.INIT_DIM
self.conv1 = conv(in_channels,
self.inplanes,
kernel_size=space_n_time_m(3, 1),
stride=1,
D=D)
self.bn1 = get_norm(NormType.BATCH_NORM,
self.inplanes,
D=self.D,
bn_momentum=bn_momentum)
self.relu = ME.MinkowskiReLU(inplace=True)
self.pool = sum_pool(kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
D=D)
self.layer1 = self._make_layer(self.BLOCK,
self.PLANES[0],
self.LAYERS[0],
stride=space_n_time_m(2, 1),
dilation=space_n_time_m(
dilations[0], 1))
self.layer2 = self._make_layer(self.BLOCK,
self.PLANES[1],
self.LAYERS[1],
stride=space_n_time_m(2, 1),
dilation=space_n_time_m(
dilations[1], 1))
self.layer3 = self._make_layer(self.BLOCK,
self.PLANES[2],
self.LAYERS[2],
stride=space_n_time_m(2, 1),
dilation=space_n_time_m(
dilations[2], 1))
self.layer4 = self._make_layer(self.BLOCK,
self.PLANES[3],
self.LAYERS[3],
stride=space_n_time_m(2, 1),
dilation=space_n_time_m(
dilations[3], 1))
self.final = conv(self.PLANES[3] * self.BLOCK.expansion,
out_channels,
kernel_size=1,
bias=True,
D=D)
def __init__(self,
inc,
outc,
inner_inc,
inner_outc,
inner_module=None,
depth=1,
bn_momentum=0.05,
dimension=-1):
ME.MinkowskiNetwork.__init__(self, dimension)
self.depth = depth
self.conv = nn.Sequential(
conv_norm_non(
inc,
inner_inc,
3,
2,
dimension,
region_type=self.REGION_TYPE,
norm_type=self.NORM_TYPE,
nonlinearity=self.NONLINEARITY), *[
get_block(
self.NORM_TYPE,
inner_inc,
inner_inc,
bn_momentum=bn_momentum,
region_type=self.REGION_TYPE,
dimension=dimension) for d in range(depth)
])
self.inner_module = inner_module
self.convtr = nn.Sequential(
conv_tr(
in_channels=inner_outc,
out_channels=inner_outc,
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
region_type=self.REGION_TYPE,
dimension=dimension),
get_norm(
self.NORM_TYPE, inner_outc, bn_momentum=bn_momentum, dimension=dimension),
get_nonlinearity(self.NONLINEARITY))
self.cat_conv = conv_norm_non(
inner_outc + inc,
outc,
1,
1,
dimension,
norm_type=self.NORM_TYPE,
nonlinearity=self.NONLINEARITY)
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilation=1,
norm_type=NormType.BATCH_NORM,
bn_momentum=0.1):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False,
D=self.D),
get_norm(norm_type,
planes * block.expansion,
D=self.D,
bn_momentum=bn_momentum),
)
layers = []
layers.append(
block(self.inplanes,
planes,
stride=stride,
dilation=dilation,
downsample=downsample,
conv_type=self.CONV_TYPE,
D=self.D))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
stride=1,
dilation=dilation,
conv_type=self.CONV_TYPE,
D=self.D))
return nn.Sequential(*layers)
def conv_norm_non(inc,
outc,
kernel_size,
stride,
dimension,
bn_momentum=0.05,
region_type=ME.RegionType.HYPER_CUBE,
norm_type='BN',
nonlinearity='ELU'):
return nn.Sequential(
conv(in_channels=inc,
out_channels=outc,
kernel_size=kernel_size,
stride=stride,
dilation=1,
bias=False,
region_type=region_type,
dimension=dimension),
get_norm(norm_type, outc, bn_momentum=bn_momentum,
dimension=dimension), get_nonlinearity(nonlinearity))
def __init__(self,
in_channels=3,
out_channels=32,
bn_momentum=0.1,
normalize_feature=None,
conv1_kernel_size=None,
D=3):
ME.MinkowskiNetwork.__init__(self, D)
NORM_TYPE = self.NORM_TYPE
BLOCK_NORM_TYPE = self.BLOCK_NORM_TYPE
CHANNELS = self.CHANNELS
TR_CHANNELS = self.TR_CHANNELS
self.normalize_feature = normalize_feature
self.conv1 = ME.MinkowskiConvolution(
in_channels=in_channels,
out_channels=CHANNELS[1],
kernel_size=conv1_kernel_size,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm1 = get_norm(NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.block1 = get_block(
BLOCK_NORM_TYPE, CHANNELS[1], CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.conv2 = ME.MinkowskiConvolution(
in_channels=CHANNELS[1],
out_channels=CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2 = get_norm(NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.block2 = get_block(
BLOCK_NORM_TYPE, CHANNELS[2], CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv3 = ME.MinkowskiConvolution(
in_channels=CHANNELS[2],
out_channels=CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3 = get_norm(NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.block3 = get_block(
BLOCK_NORM_TYPE, CHANNELS[3], CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv4 = ME.MinkowskiConvolution(
in_channels=CHANNELS[3],
out_channels=CHANNELS[4],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm4 = get_norm(NORM_TYPE, CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.block4 = get_block(
BLOCK_NORM_TYPE, CHANNELS[4], CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.conv4_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[4],
out_channels=TR_CHANNELS[4],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm4_tr = get_norm(NORM_TYPE, TR_CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.block4_tr = get_block(
BLOCK_NORM_TYPE, TR_CHANNELS[4], TR_CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.conv3_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[3] + TR_CHANNELS[4],
out_channels=TR_CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3_tr = get_norm(NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.block3_tr = get_block(
BLOCK_NORM_TYPE, TR_CHANNELS[3], TR_CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv2_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[2] + TR_CHANNELS[3],
out_channels=TR_CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2_tr = get_norm(NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.block2_tr = get_block(
BLOCK_NORM_TYPE, TR_CHANNELS[2], TR_CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv1_tr = ME.MinkowskiConvolution(
in_channels=CHANNELS[1] + TR_CHANNELS[2],
out_channels=TR_CHANNELS[1],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
# self.block1_tr = BasicBlockBN(TR_CHANNELS[1], TR_CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.final = ME.MinkowskiConvolution(
in_channels=TR_CHANNELS[1],
out_channels=out_channels,
kernel_size=1,
stride=1,
dilation=1,
has_bias=True,
dimension=D)
def __init__(self,
in_channels=3,
out_channels=32,
bn_momentum=0.1,
conv1_kernel_size=3,
normalize_feature=False,
D=3):
ME.MinkowskiNetwork.__init__(self, D)
NORM_TYPE = self.NORM_TYPE
BLOCK_NORM_TYPE = self.BLOCK_NORM_TYPE
CHANNELS = self.CHANNELS
TR_CHANNELS = self.TR_CHANNELS
REGION_TYPE = self.REGION_TYPE
self.normalize_feature = normalize_feature
self.conv1 = conv(
in_channels=in_channels,
out_channels=CHANNELS[1],
kernel_size=conv1_kernel_size,
stride=1,
dilation=1,
has_bias=False,
region_type=ME.RegionType.HYPERCUBE,
dimension=D)
self.norm1 = get_norm(NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, dimension=D)
self.block1 = get_block(
BLOCK_NORM_TYPE,
CHANNELS[1],
CHANNELS[1],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.pool2 = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D)
self.conv2 = conv(
in_channels=CHANNELS[1],
out_channels=CHANNELS[2],
kernel_size=3,
stride=1,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm2 = get_norm(NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, dimension=D)
self.block2 = get_block(
BLOCK_NORM_TYPE,
CHANNELS[2],
CHANNELS[2],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.pool3 = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D)
self.conv3 = conv(
in_channels=CHANNELS[2],
out_channels=CHANNELS[3],
kernel_size=3,
stride=1,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm3 = get_norm(NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, dimension=D)
self.block3 = get_block(
BLOCK_NORM_TYPE,
CHANNELS[3],
CHANNELS[3],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.pool4 = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D)
self.conv4 = conv(
in_channels=CHANNELS[3],
out_channels=CHANNELS[4],
kernel_size=3,
stride=1,
dilation=1,
has_bias=False,
region_type=ME.RegionType.HYPERCUBE,
dimension=D)
self.norm4 = get_norm(NORM_TYPE, CHANNELS[4], bn_momentum=bn_momentum, dimension=D)
self.block4 = get_block(
BLOCK_NORM_TYPE,
CHANNELS[4],
CHANNELS[4],
bn_momentum=bn_momentum,
region_type=ME.RegionType.HYPERCUBE,
dimension=D)
self.conv4_tr = conv_tr(
in_channels=CHANNELS[4],
out_channels=TR_CHANNELS[4],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
region_type=ME.RegionType.HYPERCUBE,
dimension=D)
self.norm4_tr = get_norm(
NORM_TYPE, TR_CHANNELS[4], bn_momentum=bn_momentum, dimension=D)
self.block4_tr = get_block(
BLOCK_NORM_TYPE,
TR_CHANNELS[4],
TR_CHANNELS[4],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.conv3_tr = conv_tr(
in_channels=CHANNELS[3] + TR_CHANNELS[4],
out_channels=TR_CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm3_tr = get_norm(
NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, dimension=D)
self.block3_tr = get_block(
BLOCK_NORM_TYPE,
TR_CHANNELS[3],
TR_CHANNELS[3],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.conv2_tr = conv_tr(
in_channels=CHANNELS[2] + TR_CHANNELS[3],
out_channels=TR_CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm2_tr = get_norm(
NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, dimension=D)
self.block2_tr = get_block(
BLOCK_NORM_TYPE,
TR_CHANNELS[2],
TR_CHANNELS[2],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D)
self.conv1_tr = conv(
in_channels=CHANNELS[1] + TR_CHANNELS[2],
out_channels=TR_CHANNELS[1],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
# self.block1_tr = BasicBlockBN(TR_CHANNELS[1], TR_CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.final = ME.MinkowskiConvolution(
in_channels=TR_CHANNELS[1],
out_channels=out_channels,
kernel_size=1,
stride=1,
dilation=1,
has_bias=True,
dimension=D)
def __init__(self,
in_channels=3,
out_channels=32,
bn_momentum=0.1,
conv1_kernel_size=3,
normalize_feature=False,
D=3):
ME.MinkowskiNetwork.__init__(self, D)
NORM_TYPE = self.NORM_TYPE
BLOCK_NORM_TYPE = self.BLOCK_NORM_TYPE
CHANNELS = self.CHANNELS
TR_CHANNELS = self.TR_CHANNELS
DEPTHS = self.DEPTHS
REGION_TYPE = self.REGION_TYPE
self.normalize_feature = normalize_feature
self.conv1 = conv(
in_channels=in_channels,
out_channels=CHANNELS[1],
kernel_size=conv1_kernel_size,
stride=1,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm1 = get_norm(NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, dimension=D)
self.block1 = nn.Sequential(*[
get_block(
BLOCK_NORM_TYPE,
CHANNELS[1],
CHANNELS[1],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D) for d in range(DEPTHS[1])
])
self.pool2 = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D)
self.conv2 = conv(
in_channels=CHANNELS[1],
out_channels=CHANNELS[2],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm2 = get_norm(NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, dimension=D)
self.block2 = nn.Sequential(*[
get_block(
BLOCK_NORM_TYPE,
CHANNELS[2],
CHANNELS[2],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D) for d in range(DEPTHS[2])
])
self.pool3 = ME.MinkowskiSumPooling(kernel_size=2, stride=2, dimension=D)
self.conv3 = conv(
in_channels=CHANNELS[2],
out_channels=CHANNELS[3],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm3 = get_norm(NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, dimension=D)
self.block3 = nn.Sequential(*[
get_block(
BLOCK_NORM_TYPE,
CHANNELS[3],
CHANNELS[3],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D) for d in range(DEPTHS[3])
])
self.pool3_tr = ME.MinkowskiPoolingTranspose(kernel_size=2, stride=2, dimension=D)
self.conv3_tr = conv_tr(
in_channels=CHANNELS[3],
out_channels=TR_CHANNELS[3],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm3_tr = get_norm(
NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, dimension=D)
self.block3_tr = nn.Sequential(*[
get_block(
BLOCK_NORM_TYPE,
TR_CHANNELS[3],
TR_CHANNELS[3],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D) for d in range(DEPTHS[-3])
])
self.pool2_tr = ME.MinkowskiPoolingTranspose(kernel_size=2, stride=2, dimension=D)
self.conv2_tr = conv_tr(
in_channels=CHANNELS[2] + TR_CHANNELS[3],
out_channels=TR_CHANNELS[2],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
self.norm2_tr = get_norm(
NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, dimension=D)
self.block2_tr = nn.Sequential(*[
get_block(
BLOCK_NORM_TYPE,
TR_CHANNELS[2],
TR_CHANNELS[2],
bn_momentum=bn_momentum,
region_type=REGION_TYPE,
dimension=D) for d in range(DEPTHS[-2])
])
self.conv1_tr = conv_tr(
in_channels=CHANNELS[1] + TR_CHANNELS[2],
out_channels=TR_CHANNELS[1],
kernel_size=1,
stride=1,
dilation=1,
has_bias=False,
region_type=REGION_TYPE,
dimension=D)
# self.block1_tr = BasicBlockBN(TR_CHANNELS[1], TR_CHANNELS[1], bn_momentum=bn_momentum, dimension=D)
self.final = conv(
in_channels=TR_CHANNELS[1],
out_channels=out_channels,
kernel_size=1,
stride=1,
dilation=1,
has_bias=True,
dimension=D)
def __init__(self, in_channels=3, out_channels=32, bn_momentum=0.1, D=3, config=None):
ME.MinkowskiNetwork.__init__(self, D)
NORM_TYPE = self.NORM_TYPE
bn_momentum = config.bn_momentum
CHANNELS = self.CHANNELS
TR_CHANNELS = self.TR_CHANNELS
self.normalize_feature = config.normalize_feature
self.conv1 = ME.MinkowskiConvolution(
in_channels=in_channels,
out_channels=CHANNELS[1],
kernel_size=config.conv1_kernel_size,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm1 = get_norm(NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.conv2 = ME.MinkowskiConvolution(
in_channels=CHANNELS[1],
out_channels=CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2 = get_norm(NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv3 = ME.MinkowskiConvolution(
in_channels=CHANNELS[2],
out_channels=CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3 = get_norm(NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv4 = ME.MinkowskiConvolution(
in_channels=CHANNELS[3],
out_channels=CHANNELS[4],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm4 = get_norm(NORM_TYPE, CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.conv5 = ME.MinkowskiConvolution(
in_channels=CHANNELS[4],
out_channels=CHANNELS[5],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm5 = get_norm(NORM_TYPE, CHANNELS[5], bn_momentum=bn_momentum, D=D)
self.conv5_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[5],
out_channels=TR_CHANNELS[5],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm5_tr = get_norm(NORM_TYPE, TR_CHANNELS[5], bn_momentum=bn_momentum, D=D)
self.conv4_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[4] + TR_CHANNELS[5],
out_channels=TR_CHANNELS[4],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm4_tr = get_norm(NORM_TYPE, TR_CHANNELS[4], bn_momentum=bn_momentum, D=D)
self.conv3_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[3] + TR_CHANNELS[4],
out_channels=TR_CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3_tr = get_norm(NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv2_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[2] + TR_CHANNELS[3],
out_channels=TR_CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2_tr = get_norm(NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv1_tr = ME.MinkowskiConvolution(
in_channels=CHANNELS[1] + TR_CHANNELS[2],
out_channels=TR_CHANNELS[1],
kernel_size=1,
stride=1,
dilation=1,
has_bias=True,
dimension=D)
def __init__(self,
in_channels=3,
out_channels=32,
bn_momentum=0.1,
normalize_feature=None,
conv1_kernel_size=None,
D=3):
super(SimpleNet, self).__init__(D)
NORM_TYPE = self.NORM_TYPE
CHANNELS = self.CHANNELS
TR_CHANNELS = self.TR_CHANNELS
self.normalize_feature = normalize_feature
self.conv1 = ME.MinkowskiConvolution(
in_channels=in_channels,
out_channels=CHANNELS[1],
kernel_size=conv1_kernel_size,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm1 = get_norm(NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.conv2 = ME.MinkowskiConvolution(
in_channels=CHANNELS[1],
out_channels=CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2 = get_norm(NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv3 = ME.MinkowskiConvolution(
in_channels=CHANNELS[2],
out_channels=CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3 = get_norm(NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv3_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[3],
out_channels=TR_CHANNELS[3],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm3_tr = get_norm(NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, D=D)
self.conv2_tr = ME.MinkowskiConvolutionTranspose(
in_channels=CHANNELS[2] + TR_CHANNELS[3],
out_channels=TR_CHANNELS[2],
kernel_size=3,
stride=2,
dilation=1,
has_bias=False,
dimension=D)
self.norm2_tr = get_norm(NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, D=D)
self.conv1_tr = ME.MinkowskiConvolution(
in_channels=CHANNELS[1] + TR_CHANNELS[2],
out_channels=TR_CHANNELS[1],
kernel_size=3,
stride=1,
dilation=1,
has_bias=False,
dimension=D)
self.norm1_tr = get_norm(NORM_TYPE, TR_CHANNELS[1], bn_momentum=bn_momentum, D=D)
self.final = ME.MinkowskiConvolution(
in_channels=TR_CHANNELS[1],
out_channels=out_channels,
kernel_size=1,
stride=1,
dilation=1,
has_bias=True,
dimension=D)
