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, config, 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 = config.dilations
bn_momentum = config.bn_momentum
self.inplanes = self.INIT_DIM
self.conv1 = conv(
in_channels,
self.inplanes,
kernel_size=space_n_time_m(config.conv1_kernel_size, 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))
if self.NETWORK_TYPE == NetworkType.CLASSIFICATION:
self.glob_avg = ME.MinkowskiGlobalPooling(dimension=D)
if self.HAS_LAST_BLOCK:
self.final1 = nn.Linear(self.inplanes, self.inplanes, bias=False)
self.bnfinal1 = nn.BatchNorm1d(self.inplanes)
self.final2 = nn.Linear(self.inplanes, self.inplanes, bias=False)
self.bnfinal2 = nn.BatchNorm1d(self.inplanes)
self.final = nn.Linear(self.inplanes, out_channels, bias=True)
else:
self.final = conv(
self.PLANES[3] * self.BLOCK.expansion, out_channels, kernel_size=1, bias=True, D=D)
def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
conv_type=ConvType.HYPERCUBE,
nonlinearity_type='ReLU',
bn_momentum=0.1,
D=3):
super(BottleneckBase, self).__init__()
self.conv1 = conv(inplanes, planes, kernel_size=1, D=D)
self.norm1 = get_norm(self.NORM_TYPE,
planes,
D,
bn_momentum=bn_momentum)
self.conv2 = conv(planes,
planes,
kernel_size=3,
stride=stride,
dilation=dilation,
conv_type=conv_type,
D=D)
self.norm2 = get_norm(self.NORM_TYPE,
planes,
D,
bn_momentum=bn_momentum)
self.conv3 = conv(planes, planes * self.expansion, kernel_size=1, D=D)
self.norm3 = get_norm(self.NORM_TYPE,
planes * self.expansion,
D,
bn_momentum=bn_momentum)
self.downsample = downsample
self.nonlinearity_type = nonlinearity_type
def network_initialization(self, in_channels, out_channels, config, 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 = config.dilations
bn_momentum = config.bn_momentum
self.inplanes = self.INIT_DIM
self.conv1 = conv(
in_channels,
self.inplanes,
kernel_size=space_n_time_m(config.conv1_kernel_size, 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 network_initialization(self, in_channels, config):
dilations = config.dilations
bn_momentum = config.bn_momentum
self.inplanes = self.INIT_DIM
self.conv1 = conv(in_channels,
self.inplanes,
kernel_size=5,
stride=1,
D=self.D)
self.bn1 = get_norm(self.NORM_TYPE,
self.inplanes,
D=self.D,
bn_momentum=bn_momentum)
self.relu = ME.MinkowskiReLU(inplace=True)
self.pool = sum_pool(kernel_size=2, stride=2, D=self.D)
self.layer1 = self._make_layer(self.BLOCK,
self.PLANES[0],
self.LAYERS[0],
stride=2,
norm_type=self.NORM_TYPE,
dilation=dilations[0])
self.layer2 = self._make_layer(self.BLOCK,
self.PLANES[1],
self.LAYERS[1],
stride=2,
norm_type=self.NORM_TYPE,
dilation=dilations[1])
self.layer3 = self._make_layer(self.BLOCK,
self.PLANES[2],
self.LAYERS[2],
stride=2,
norm_type=self.NORM_TYPE,
dilation=dilations[2])
self.layer4 = self._make_layer(self.BLOCK,
self.PLANES[3],
self.LAYERS[3],
stride=2,
norm_type=self.NORM_TYPE,
dilation=dilations[3])
self.layer5 = self._make_layer(self.BLOCK,
self.PLANES[4],
self.LAYERS[4],
stride=2,
norm_type=self.NORM_TYPE,
dilation=dilations[4])
def network_initialization(self, in_channels, out_channels, config, D):
self.conv_feat1 = conv(in_channels[0], config.upsample_feat_size, 3, D=D)
self.conv_feat2 = conv(in_channels[1], config.upsample_feat_size, 3, D=D)
self.conv_feat3 = conv(in_channels[2], config.upsample_feat_size, 3, D=D)
self.conv_feat4 = conv(in_channels[3], config.upsample_feat_size, 3, D=D)
self.bn_feat1 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_feat2 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_feat3 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_feat4 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.conv_up2 = conv_tr(
config.upsample_feat_size, config.upsample_feat_size, kernel_size=2, upsample_stride=2,
dilation=1, bias=False, D=3)
self.conv_up3 = conv_tr(
config.upsample_feat_size, config.upsample_feat_size, kernel_size=2, upsample_stride=2,
dilation=1, bias=False, D=3)
self.conv_up4 = conv_tr(
config.upsample_feat_size, config.upsample_feat_size, kernel_size=2, upsample_stride=2,
dilation=1, bias=False, D=3)
self.conv_up5 = conv_tr(
config.upsample_feat_size, config.upsample_feat_size, kernel_size=2, upsample_stride=2,
dilation=1, bias=False, D=3)
self.conv_up6 = conv_tr(
config.upsample_feat_size, config.upsample_feat_size, kernel_size=2, upsample_stride=2,
dilation=1, bias=False, D=3)
self.bn_up2 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_up3 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_up4 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_up5 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.bn_up6 = get_norm(
NormType.BATCH_NORM, config.upsample_feat_size, D=3, bn_momentum=config.bn_momentum)
self.conv_final = conv(config.upsample_feat_size, out_channels, 1, D=D)
self.relu = ME.MinkowskiReLU(inplace=False)
def _make_layer(self,
block,
inplanes,
planes,
num_blocks,
stride=1,
dilation=1,
norm_type=NormType.BATCH_NORM,
nonlinearity_type='ReLU',
bn_momentum=0.1):
downsample = None
if stride != 1 or inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv(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(inplanes,
planes,
stride=stride,
dilation=dilation,
downsample=downsample,
conv_type=self.CONV_TYPE,
nonlinearity_type=nonlinearity_type,
D=self.D))
inplanes = planes * block.expansion
for i in range(1, num_blocks):
layers.append(
block(inplanes,
planes,
stride=1,
dilation=dilation,
conv_type=self.CONV_TYPE,
nonlinearity_type=nonlinearity_type,
D=self.D))
return mySequential(*layers)
def network_initialization(self, in_channels, out_channels, config, D):
# Setup net_metadata
dilations = self.DILATIONS
bn_momentum = config.bn_momentum
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)
# Output of the first conv concated to conv6
self.inplanes = self.INIT_DIM
self.conv0p1s1 = conv(in_channels,
self.inplanes,
kernel_size=space_n_time_m(
config.conv1_kernel_size, 1),
stride=1,
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn0 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.conv1p1s2 = conv(self.inplanes,
self.inplanes,
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn1 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block1 = self._make_layer(
self.BLOCK,
self.PLANES[0],
self.LAYERS[0],
dilation=dilations[0],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv2p2s2 = conv(self.inplanes,
self.inplanes,
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn2 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block2 = self._make_layer(
self.BLOCK,
self.PLANES[1],
self.LAYERS[1],
dilation=dilations[1],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv3p4s2 = conv(self.inplanes,
self.inplanes,
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn3 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block3 = self._make_layer(
self.BLOCK,
self.PLANES[2],
self.LAYERS[2],
dilation=dilations[2],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv4p8s2 = conv(self.inplanes,
self.inplanes,
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn4 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block4 = self._make_layer(
self.BLOCK,
self.PLANES[3],
self.LAYERS[3],
dilation=dilations[3],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr4p16s2 = conv_tr(self.inplanes,
self.PLANES[4],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr4 = get_norm(self.NORM_TYPE,
self.PLANES[4],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[4] + self.PLANES[2] * self.BLOCK.expansion
self.block5 = self._make_layer(
self.BLOCK,
self.PLANES[4],
self.LAYERS[4],
dilation=dilations[4],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr5p8s2 = conv_tr(self.inplanes,
self.PLANES[5],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr5 = get_norm(self.NORM_TYPE,
self.PLANES[5],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[5] + self.PLANES[1] * self.BLOCK.expansion
self.block6 = self._make_layer(
self.BLOCK,
self.PLANES[5],
self.LAYERS[5],
dilation=dilations[5],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr6p4s2 = conv_tr(self.inplanes,
self.PLANES[6],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr6 = get_norm(self.NORM_TYPE,
self.PLANES[6],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[6] + self.PLANES[0] * self.BLOCK.expansion
self.block7 = self._make_layer(
self.BLOCK,
self.PLANES[6],
self.LAYERS[6],
dilation=dilations[6],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr7p2s2 = conv_tr(self.inplanes,
self.PLANES[7],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr7 = get_norm(self.NORM_TYPE,
self.PLANES[7],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[7] + self.INIT_DIM
self.block8 = self._make_layer(
self.BLOCK,
self.PLANES[7],
self.LAYERS[7],
dilation=dilations[7],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.final = conv(self.PLANES[7],
out_channels,
kernel_size=1,
stride=1,
bias=True,
D=D)
def network_initialization(self, in_channels, out_channels, config, D):
if not isinstance(self.BLOCK, list): # if single type
self.BLOCK = [self.BLOCK] * len(self.PLANES)
# print('IN CHANNEL inside the model {}'.format(in_channels))
# Setup net_metadata
dilations = self.DILATIONS
bn_momentum = config.bn_momentum
block_noexpansion = True
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)
if config.xyz_input is not None:
if config.xyz_input:
in_channels = in_channels + 3
if config.dataset == 'SemanticKITTI':
in_channels = 4
if config.dataset == 'S3DIS':
in_channels = 9
# Output of the first conv concated to conv6
self.inplanes = self.INIT_DIM
self.conv0p1s1 = conv(in_channels,
self.inplanes,
kernel_size=space_n_time_m(
config.conv1_kernel_size, 1),
stride=1,
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bn0 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.conv1p1s2 = conv(
self.inplanes,
self.inplanes if not block_noexpansion else self.PLANES[0],
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.inplanes = self.inplanes if not block_noexpansion else self.PLANES[
0]
self.bn1 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block1 = self._make_layer(
self.BLOCK[0],
self.PLANES[0],
self.LAYERS[0],
dilation=dilations[0],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv2p2s2 = conv(
self.inplanes,
self.inplanes if not block_noexpansion else self.PLANES[1],
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.inplanes = self.inplanes if not block_noexpansion else self.PLANES[
1]
self.bn2 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block2 = self._make_layer(
self.BLOCK[1],
self.PLANES[1],
self.LAYERS[1],
dilation=dilations[1],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv3p4s2 = conv(
self.inplanes,
self.inplanes if not block_noexpansion else self.PLANES[2],
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.inplanes = self.inplanes if not block_noexpansion else self.PLANES[
2]
self.bn3 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block3 = self._make_layer(
self.BLOCK[2],
self.PLANES[2],
self.LAYERS[2],
dilation=dilations[2],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.conv4p8s2 = conv(
self.inplanes,
self.inplanes if not block_noexpansion else self.PLANES[3],
kernel_size=space_n_time_m(2, 1),
stride=space_n_time_m(2, 1),
dilation=1,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.inplanes = self.inplanes if not block_noexpansion else self.PLANES[
3]
self.bn4 = get_norm(self.NORM_TYPE,
self.inplanes,
D,
bn_momentum=bn_momentum)
self.block4 = self._make_layer(
self.BLOCK[3],
self.PLANES[3],
self.LAYERS[3],
dilation=dilations[3],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr4p16s2 = conv_tr(self.inplanes,
self.PLANES[4],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr4 = get_norm(self.NORM_TYPE,
self.PLANES[4],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[
4] + self.PLANES[2] * self.BLOCK[4].expansion
self.block5 = self._make_layer(
self.BLOCK[4],
self.PLANES[4],
self.LAYERS[4],
dilation=dilations[4],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr5p8s2 = conv_tr(self.inplanes,
self.PLANES[5],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr5 = get_norm(self.NORM_TYPE,
self.PLANES[5],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[
5] + self.PLANES[1] * self.BLOCK[5].expansion
self.block6 = self._make_layer(
self.BLOCK[5],
self.PLANES[5],
self.LAYERS[5],
dilation=dilations[5],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr6p4s2 = conv_tr(self.inplanes,
self.PLANES[6],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr6 = get_norm(self.NORM_TYPE,
self.PLANES[6],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[
6] + self.PLANES[0] * self.BLOCK[6].expansion
self.block7 = self._make_layer(
self.BLOCK[6],
self.PLANES[6],
self.LAYERS[6],
dilation=dilations[6],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.convtr7p2s2 = conv_tr(self.inplanes,
self.PLANES[7],
kernel_size=space_n_time_m(2, 1),
upsample_stride=space_n_time_m(2, 1),
dilation=1,
bias=False,
conv_type=self.NON_BLOCK_CONV_TYPE,
D=D)
self.bntr7 = get_norm(self.NORM_TYPE,
self.PLANES[7],
D,
bn_momentum=bn_momentum)
self.inplanes = self.PLANES[7] + self.INIT_DIM
self.block8 = self._make_layer(
self.BLOCK[7],
self.PLANES[7],
self.LAYERS[7],
dilation=dilations[7],
norm_type=self.NORM_TYPE,
nonlinearity_type=self.config.nonlinearity,
bn_momentum=bn_momentum)
self.final = conv(self.PLANES[7],
out_channels,
kernel_size=1,
stride=1,
bias=True,
D=D)
if config.enable_point_branch:
self.point_transform_mlp = nn.ModuleList([
nn.Sequential(
nn.Linear(self.INIT_DIM, self.PLANES[3]),
# nn.BatchNorm1d(self.PLANES[3]),
nn.ReLU(True)),
nn.Sequential(
nn.Linear(self.PLANES[3], self.PLANES[5]),
#nn.BatchNorm1d(self.PLANES[5]),
nn.ReLU(True)),
nn.Sequential(
nn.Linear(self.PLANES[5], self.PLANES[7]),
# nn.BatchNorm1d(self.PLANES[7]),
nn.ReLU(True))
])
self.downsample16x = nn.Sequential(
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3),
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3),
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3),
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3))
self.downsample4x = nn.Sequential(
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3),
ME.MinkowskiMaxPooling(kernel_size=2, stride=2, dimension=3))
self.dropout = nn.Dropout(0.1, True)
# self.dropout = nn.Dropout(0.3, True)
self.interpolate = ME.MinkowskiInterpolation(
return_kernel_map=False, return_weights=False)
