def __init__(self, model_cfg, input_channels, grid_size, voxel_size,
point_cloud_range, **kwargs):
super().__init__()
self.model_cfg = model_cfg
self.sparse_shape = grid_size[::-1] + [1, 0, 0]
self.voxel_size = voxel_size
self.point_cloud_range = point_cloud_range
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(input_channels,
16,
3,
padding=1,
bias=False,
indice_key='subm1'),
norm_fn(16),
nn.ReLU(),
)
block = post_act_block
self.conv1 = spconv.SparseSequential(
block(16, 16, 3, norm_fn=norm_fn, padding=1, indice_key='subm1'), )
self.conv2 = spconv.SparseSequential(
# [1600, 1408, 41] <- [800, 704, 21]
block(16,
32,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv2',
conv_type='spconv'),
block(32, 32, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
block(32, 32, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
)
self.conv3 = spconv.SparseSequential(
# [800, 704, 21] <- [400, 352, 11]
block(32,
64,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv3',
conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
)
self.conv4 = spconv.SparseSequential(
# [400, 352, 11] <- [200, 176, 5]
block(64,
64,
3,
norm_fn=norm_fn,
stride=2,
padding=(0, 1, 1),
indice_key='spconv4',
conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
)
last_pad = 0
last_pad = self.model_cfg.get('last_pad', last_pad)
self.conv_out = spconv.SparseSequential(
# [200, 150, 5] -> [200, 150, 2]
spconv.SparseConv3d(64,
128, (3, 1, 1),
stride=(2, 1, 1),
padding=last_pad,
bias=False,
indice_key='spconv_down2'),
norm_fn(128),
nn.ReLU(),
)
# decoder
# [400, 352, 11] <- [200, 176, 5]
self.conv_up_t4 = SparseBasicBlock(64,
64,
indice_key='subm4',
norm_fn=norm_fn)
self.conv_up_m4 = block(128,
64,
3,
norm_fn=norm_fn,
padding=1,
indice_key='subm4')
self.inv_conv4 = block(64,
64,
3,
norm_fn=norm_fn,
indice_key='spconv4',
conv_type='inverseconv')
# [800, 704, 21] <- [400, 352, 11]
self.conv_up_t3 = SparseBasicBlock(64,
64,
indice_key='subm3',
norm_fn=norm_fn)
self.conv_up_m3 = block(128,
64,
3,
norm_fn=norm_fn,
padding=1,
indice_key='subm3')
self.inv_conv3 = block(64,
32,
3,
norm_fn=norm_fn,
indice_key='spconv3',
conv_type='inverseconv')
# [1600, 1408, 41] <- [800, 704, 21]
self.conv_up_t2 = SparseBasicBlock(32,
32,
indice_key='subm2',
norm_fn=norm_fn)
self.conv_up_m2 = block(64, 32, 3, norm_fn=norm_fn, indice_key='subm2')
self.inv_conv2 = block(32,
16,
3,
norm_fn=norm_fn,
indice_key='spconv2',
conv_type='inverseconv')
# [1600, 1408, 41] <- [1600, 1408, 41]
self.conv_up_t1 = SparseBasicBlock(16,
16,
indice_key='subm1',
norm_fn=norm_fn)
self.conv_up_m1 = block(32, 16, 3, norm_fn=norm_fn, indice_key='subm1')
self.conv5 = spconv.SparseSequential(
block(16, 16, 3, norm_fn=norm_fn, padding=1, indice_key='subm1'))
self.num_point_features = 16
def __init__(self,
output_shape,
use_norm=True,
num_input_features=128,
num_filters_down1=[64],
num_filters_down2=[64, 64],
name='SparseMiddleExtractor'):
super(SparseMiddleExtractor, self).__init__()
self.name = name
if use_norm:
BatchNorm1d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm1d)
Linear = change_default_args(bias=False)(nn.Linear)
else:
BatchNorm1d = Empty
Linear = change_default_args(bias=True)(nn.Linear)
sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0]
# sparse_shape[0] = 11
print(sparse_shape)
self.sparse_shape = sparse_shape
self.scn_input = scn.InputLayer(3, sparse_shape.tolist())
self.voxel_output_shape = output_shape
middle_layers = []
num_filters = [num_input_features] + num_filters_down1
# num_filters = [64] + num_filters_down1
filters_pairs_d1 = [[num_filters[i], num_filters[i + 1]]
for i in range(len(num_filters) - 1)]
for i, o in filters_pairs_d1:
middle_layers.append(
spconv.SubMConv3d(i, o, 3, bias=False, indice_key="subm0"))
middle_layers.append(BatchNorm1d(o))
middle_layers.append(nn.ReLU())
middle_layers.append(
spconv.SparseConv3d(
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(BatchNorm1d(num_filters[-1]))
middle_layers.append(nn.ReLU())
# assert len(num_filters_down2) > 0
if len(num_filters_down1) == 0:
num_filters = [num_filters[-1]] + num_filters_down2
else:
num_filters = [num_filters_down1[-1]] + num_filters_down2
filters_pairs_d2 = [[num_filters[i], num_filters[i + 1]]
for i in range(len(num_filters) - 1)]
for i, o in filters_pairs_d2:
middle_layers.append(
spconv.SubMConv3d(i, o, 3, bias=False, indice_key="subm1"))
middle_layers.append(BatchNorm1d(o))
middle_layers.append(nn.ReLU())
middle_layers.append(
spconv.SparseConv3d(
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(BatchNorm1d(num_filters[-1]))
middle_layers.append(nn.ReLU())
self.middle_conv = spconv.SparseSequential(*middle_layers)
def __init__(self, in_channel, config):
super().__init__()
self.print_time = False
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(in_channel,
16,
3,
bias=False,
padding=1,
indice_key="subm1"),
norm_fn(16),
nn.ReLU(),
)
self.config = config
block = self.convblock
if self.config["add_layers_for_conv3d"]:
self.conv1 = spconv.SparseSequential(
block(16,
16,
3,
padding=1,
norm_fn=norm_fn,
indice_key="subm1"),
block(16,
16,
3,
padding=1,
norm_fn=norm_fn,
indice_key="subm1"),
)
self.conv2 = spconv.SparseSequential(
block(16,
32,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
)
self.conv3 = spconv.SparseSequential(
block(32,
64,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
)
self.conv4 = spconv.SparseSequential(
block(64,
128,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
)
self.conv_out = spconv.SparseSequential(
block(128,
256, (3, 1, 1),
stride=(2, 1, 1),
padding=0,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="conv_down"),
block(256,
256,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm5"),
block(256,
256,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm5"),
block(256,
256,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm5"),
)
else:
self.conv1 = spconv.SparseSequential(
block(16,
16,
3,
padding=1,
norm_fn=norm_fn,
indice_key="subm1"))
self.conv2 = spconv.SparseSequential(
block(16,
32,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
block(32,
32,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm2"),
)
self.conv3 = spconv.SparseSequential(
block(32,
64,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
block(64,
64,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm3"),
)
self.conv4 = spconv.SparseSequential(
block(64,
128,
3,
stride=2,
padding=1,
norm_fn=norm_fn,
conv_type="spconv",
indice_key="spconv4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
block(128,
128,
3,
stride=1,
padding=1,
norm_fn=norm_fn,
conv_type="subm",
indice_key="subm4"),
)
self.conv_out = spconv.SparseSequential(
spconv.SparseConv3d(128,
256,
kernel_size=(3, 1, 1),
stride=(2, 1, 1),
padding=0,
indice_key="conv_down"), norm_fn(256),
nn.ReLU())
self.ret = {}
def __init__(self, model_cfg, input_channels, grid_size, **kwargs):
super().__init__()
self.model_cfg = model_cfg
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.sparse_shape = grid_size[::-1] + [1, 0, 0]
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(input_channels,
16,
3,
padding=1,
bias=False,
indice_key='subm1'),
norm_fn(16),
nn.ReLU(),
)
block = post_act_block
self.conv1 = spconv.SparseSequential(
SparseBasicBlock(16, 16, norm_fn=norm_fn, indice_key='res1'),
SparseBasicBlock(16, 16, norm_fn=norm_fn, indice_key='res1'),
)
self.conv2 = spconv.SparseSequential(
# [1600, 1408, 41] <- [800, 704, 21]
block(16,
32,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv2',
conv_type='spconv'),
SparseBasicBlock(32, 32, norm_fn=norm_fn, indice_key='res2'),
SparseBasicBlock(32, 32, norm_fn=norm_fn, indice_key='res2'),
)
self.conv3 = spconv.SparseSequential(
# [800, 704, 21] <- [400, 352, 11]
block(32,
64,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv3',
conv_type='spconv'),
SparseBasicBlock(64, 64, norm_fn=norm_fn, indice_key='res3'),
SparseBasicBlock(64, 64, norm_fn=norm_fn, indice_key='res3'),
)
self.conv4 = spconv.SparseSequential(
# [400, 352, 11] <- [200, 176, 5]
block(64,
128,
3,
norm_fn=norm_fn,
stride=2,
padding=(0, 1, 1),
indice_key='spconv4',
conv_type='spconv'),
SparseBasicBlock(128, 128, norm_fn=norm_fn, indice_key='res4'),
SparseBasicBlock(128, 128, norm_fn=norm_fn, indice_key='res4'),
)
last_pad = 0
last_pad = self.model_cfg.get('last_pad', last_pad)
self.conv_out = spconv.SparseSequential(
# [200, 150, 5] -> [200, 150, 2]
spconv.SparseConv3d(128,
128, (3, 1, 1),
stride=(2, 1, 1),
padding=last_pad,
bias=False,
indice_key='spconv_down2'),
norm_fn(128),
nn.ReLU(),
)
self.num_point_features = 128
def __init__(self, cfg):
super().__init__()
input_c = cfg.input_channel
m = cfg.m
classes = cfg.classes
block_reps = cfg.block_reps
block_residual = cfg.block_residual
self.cluster_radius = cfg.cluster_radius
self.cluster_meanActive = cfg.cluster_meanActive
self.cluster_shift_meanActive = cfg.cluster_shift_meanActive
self.cluster_npoint_thre = cfg.cluster_npoint_thre
self.score_scale = cfg.score_scale
self.score_fullscale = cfg.score_fullscale
self.mode = cfg.score_mode
self.prepare_iters = cfg.prepare_iters
self.pretrain_path = cfg.pretrain_path
self.pretrain_module = cfg.pretrain_module
self.fix_module = cfg.fix_module
norm_fn = functools.partial(nn.BatchNorm1d, eps=1e-4, momentum=0.1)
if block_residual:
block = ResidualBlock
else:
block = VGGBlock
if cfg.use_coords:
input_c += 3
#### backbone
self.input_conv = spconv.SparseSequential(
spconv.SubMConv3d(input_c,
m,
kernel_size=3,
padding=1,
bias=False,
indice_key='subm1'))
self.unet = UBlock([m, 2 * m, 3 * m, 4 * m, 5 * m, 6 * m, 7 * m],
norm_fn,
block_reps,
block,
indice_key_id=1)
self.output_layer = spconv.SparseSequential(norm_fn(m), nn.ReLU())
#### semantic segmentation
self.linear = nn.Linear(m, classes) # bias(default): True
#### offset
self.offset = nn.Sequential(nn.Linear(m, m, bias=True), norm_fn(m),
nn.ReLU())
self.offset_linear = nn.Linear(m, 3, bias=True)
#### score branch
self.score_unet = UBlock([m, 2 * m],
norm_fn,
2,
block,
indice_key_id=1)
self.score_outputlayer = spconv.SparseSequential(norm_fn(m), nn.ReLU())
self.score_linear = nn.Linear(m, 1)
self.apply(self.set_bn_init)
#### fix parameter
module_map = {
'input_conv': self.input_conv,
'unet': self.unet,
'output_layer': self.output_layer,
'linear': self.linear,
'offset': self.offset,
'offset_linear': self.offset_linear,
'score_unet': self.score_unet,
'score_outputlayer': self.score_outputlayer,
'score_linear': self.score_linear
}
for m in self.fix_module:
mod = module_map[m]
for param in mod.parameters():
param.requires_grad = False
#### load pretrain weights
if self.pretrain_path is not None:
pretrain_dict = torch.load(self.pretrain_path)
for m in self.pretrain_module:
print("Load pretrained " + m +
": %d/%d" % utils.load_model_param(
module_map[m], pretrain_dict, prefix=m))
def __init__(self, input_channels, **kwargs):
super().__init__(unet_target_cfg=cfg.MODEL.RPN.BACKBONE.TARGET_CONFIG)
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(input_channels, 16, 3, padding=1, bias=False, indice_key='subm1'),
norm_fn(16),
nn.ReLU(),
)
block = self.post_act_block
self.conv1 = spconv.SparseSequential(
block(16, 16, 3, norm_fn=norm_fn, padding=1, indice_key='subm1'),
)
self.conv2 = spconv.SparseSequential(
# [1600, 1408, 41] <- [800, 704, 21]
block(16, 32, 3, norm_fn=norm_fn, stride=2, padding=1, indice_key='spconv2', conv_type='spconv'),
block(32, 32, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
block(32, 32, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
)
self.conv3 = spconv.SparseSequential(
# [800, 704, 21] <- [400, 352, 11]
block(32, 64, 3, norm_fn=norm_fn, stride=2, padding=1, indice_key='spconv3', conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
)
self.conv4 = spconv.SparseSequential(
# [400, 352, 11] <- [200, 176, 5]
block(64, 64, 3, norm_fn=norm_fn, stride=2, padding=(0, 1, 1), indice_key='spconv4', conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
)
last_pad = 0 if cfg.DATA_CONFIG.VOXEL_GENERATOR.VOXEL_SIZE[-1] in [0.1, 0.2] else (1, 0, 0)
self.conv_out = spconv.SparseSequential(
# [200, 150, 5] -> [200, 150, 2]
spconv.SparseConv3d(64, 128, (3, 1, 1), stride=(2, 1, 1), padding=last_pad,
bias=False, indice_key='spconv_down2'),
norm_fn(128),
nn.ReLU(),
)
# decoder
# [400, 352, 11] <- [200, 176, 5]
self.conv_up_t4 = SparseBasicBlock(64, 64, indice_key='subm4', norm_fn=norm_fn)
self.conv_up_m4 = block(128, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4')
self.inv_conv4 = block(64, 64, 3, norm_fn=norm_fn, indice_key='spconv4', conv_type='inverseconv')
# [800, 704, 21] <- [400, 352, 11]
self.conv_up_t3 = SparseBasicBlock(64, 64, indice_key='subm3', norm_fn=norm_fn)
self.conv_up_m3 = block(128, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3')
self.inv_conv3 = block(64, 32, 3, norm_fn=norm_fn, indice_key='spconv3', conv_type='inverseconv')
# [1600, 1408, 41] <- [800, 704, 21]
self.conv_up_t2 = SparseBasicBlock(32, 32, indice_key='subm2', norm_fn=norm_fn)
self.conv_up_m2 = block(64, 32, 3, norm_fn=norm_fn, indice_key='subm2')
self.inv_conv2 = block(32, 16, 3, norm_fn=norm_fn, indice_key='spconv2', conv_type='inverseconv')
# [1600, 1408, 41] <- [1600, 1408, 41]
self.conv_up_t1 = SparseBasicBlock(16, 16, indice_key='subm1', norm_fn=norm_fn)
self.conv_up_m1 = block(32, 16, 3, norm_fn=norm_fn, indice_key='subm1')
self.conv5 = spconv.SparseSequential(
block(16, 16, 3, norm_fn=norm_fn, padding=1, indice_key='subm1')
)
self.seg_cls_layer = nn.Linear(16, 1, bias=True)
self.seg_reg_layer = nn.Linear(16, 3, bias=True)
def __init__(self, input_channels):
super().__init__()
self.register_buffer('global_step', torch.LongTensor(1).zero_())
#######################################稀疏三维卷积#########################################
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.downsample_times_map = [1, 2, 4, 8]
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(input_channels,
16,
3,
padding=1,
bias=False,
indice_key='subm1'),
norm_fn(16),
nn.ReLU(),
)
self.conv1 = spconv.SparseSequential(
spconv.SparseSequential(
spconv.SubMConv3d(16,
16,
3,
padding=1,
bias=False,
indice_key='subm1'),
norm_fn(16),
nn.ReLU(),
))
self.conv2 = spconv.SparseSequential(
# [1600, 1408, 41] <- [800, 704, 21]
spconv.SparseSequential(
spconv.SparseConv3d(16,
32,
3,
stride=2,
padding=1,
bias=False,
indice_key='spconv2'),
norm_fn(32),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(32,
32,
3,
padding=1,
bias=False,
indice_key='subm2'),
norm_fn(32),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(32,
32,
3,
padding=1,
bias=False,
indice_key='subm2'),
norm_fn(32),
nn.ReLU(),
))
self.conv3 = spconv.SparseSequential(
# [800, 704, 21] <- [400, 352, 11]
spconv.SparseSequential(
spconv.SparseConv3d(32,
64,
3,
stride=2,
padding=1,
bias=False,
indice_key='spconv3'),
norm_fn(64),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(64,
64,
3,
padding=1,
bias=False,
indice_key='subm3'),
norm_fn(64),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(64,
64,
3,
padding=1,
bias=False,
indice_key='subm3'),
norm_fn(64),
nn.ReLU(),
))
self.conv4 = spconv.SparseSequential(
# [400, 352, 11] <- [200, 176, 5]
spconv.SparseSequential(
spconv.SparseConv3d(64,
64,
3,
stride=2,
padding=(0, 1, 1),
bias=False,
indice_key='spconv4'),
norm_fn(64),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(64,
64,
3,
bias=False,
indice_key='subm4',
padding=1),
norm_fn(64),
nn.ReLU(),
),
spconv.SparseSequential(
spconv.SubMConv3d(64, 64, 3, bias=False, indice_key='subm4'),
norm_fn(64),
nn.ReLU(),
))
# last_pad = 0 if cfg.DATA_CONFIG.VOXEL_GENERATOR.VOXEL_SIZE[-1] in [0.1, 0.2] else (1, 0, 0)
self.conv_out = spconv.SparseSequential(
# [200, 150, 5] -> [200, 150, 2]
spconv.SparseConv3d(
64,
128,
(3, 1, 1),
stride=(2, 1, 1),
padding=0, # last_pad
bias=False,
indice_key='spconv_down2'),
norm_fn(128),
nn.ReLU(),
)
#######################################接下来是RPN head #####################################
BatchNorm2d = partial(nn.BatchNorm2d, eps=1e-3, momentum=0.01)
Conv2d = partial(
nn.Conv2d, bias=False
) ########################################voxel_sa##########################################
ConvTranspose2d = partial(nn.ConvTranspose2d, bias=False)
self.block1 = nn.Sequential(
nn.ZeroPad2d(1),
Conv2d(256, 128, 3, stride=1),
BatchNorm2d(128),
nn.ReLU(),
Conv2d(128, 128, 3, padding=1), #1
BatchNorm2d(128),
nn.ReLU(),
Conv2d(128, 128, 3, padding=1), #2
BatchNorm2d(128),
nn.ReLU(),
Conv2d(128, 128, 3, padding=1), #3
BatchNorm2d(128),
nn.ReLU(),
Conv2d(128, 128, 3, padding=1), #4
BatchNorm2d(128),
nn.ReLU(),
Conv2d(128, 128, 3, padding=1), #5
BatchNorm2d(128),
nn.ReLU(),
)
self.block2 = nn.Sequential(
nn.ZeroPad2d(1),
Conv2d(128, 256, 3, stride=2),
BatchNorm2d(256),
nn.ReLU(),
Conv2d(256, 256, 3, padding=1), #1
BatchNorm2d(256),
nn.ReLU(),
Conv2d(256, 256, 3, padding=1), #2
BatchNorm2d(256),
nn.ReLU(),
Conv2d(256, 256, 3, padding=1), #3
BatchNorm2d(256),
nn.ReLU(),
Conv2d(256, 256, 3, padding=1), #4
BatchNorm2d(256),
nn.ReLU(),
Conv2d(256, 256, 3, padding=1), #5
BatchNorm2d(256),
nn.ReLU(),
)
self.deblock1 = nn.Sequential(ConvTranspose2d(128, 256, 1, stride=1),
BatchNorm2d(256), nn.ReLU())
self.deblock2 = nn.Sequential(ConvTranspose2d(256, 256, 2, stride=2),
BatchNorm2d(256), nn.ReLU())
self.rpn_head_conv_cls = nn.Conv2d(512, 6 * 3, 1)
self.rpn_head_conv_box = nn.Conv2d(512, 6 * 7, 1)
self.rpn_head_conv_dir_cls = nn.Conv2d(512, 6 * 2, 1)
#######################################接下来是voxeel SA #####################################
mlps = [[16, 16, 16], [16, 16, 16]]
self.conv1_sa_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[0.4, 0.8],
nsamples=[16, 16],
mlps=mlps,
use_xyz=True,
pool_method='max_pool',
)
self.conv2_sa_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[0.8, 1.2],
nsamples=[16, 32],
mlps=[[32, 32, 32], [32, 32, 32]],
use_xyz=True,
pool_method='max_pool',
)
self.conv3_sa_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[1.2, 2.4],
nsamples=[16, 32],
mlps=[[64, 64, 64], [64, 64, 64]],
use_xyz=True,
pool_method='max_pool',
)
self.conv4_sa_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[2.4, 4.8],
nsamples=[16, 32],
mlps=[[64, 64, 64], [64, 64, 64]],
use_xyz=True,
pool_method='max_pool',
)
c_in = 16 + 16 + 32 + 32 + 64 + 64 + 64 + 64 + 128 * 2 # C*D
self.raw_sa_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[0.4, 0.8],
nsamples=[16, 16],
mlps=[[1, 16, 16], [1, 16, 16]],
use_xyz=True,
pool_method='max_pool',
)
c_in += 16 + 16
self.vsa_point_feature_fusion = nn.Sequential(
nn.Linear(c_in, 128, bias=False), # c_in=640
nn.BatchNorm1d(128),
nn.ReLU(),
)
self.num_point_features = 128
self.num_point_features_before_fusion = c_in
#############################################Point Head############################################
self.point_head_cls_layer = nn.Sequential(
nn.Linear(c_in, 256, bias=False), #1
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Linear(256, 256, bias=False), #2
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Linear(256, 1, bias=True), #3
)
###########################################RCNN########################################################
self.roi_pool_layer = pointnet2_stack_modules.StackSAModuleMSG(
radii=[0.8, 1.6],
nsamples=[16, 16],
mlps=[[128, 64, 64], [128, 64, 64]],
use_xyz=True,
pool_method="max_pool")
self.rcnn_share_layer = nn.Sequential(
nn.Conv1d(6**3 * (64 + 64), 256, kernel_size=1, bias=False),
nn.BatchNorm1d(256), nn.ReLU(), nn.Dropout(0.3),
nn.Conv1d(256, 256, kernel_size=1, bias=False),
nn.BatchNorm1d(256), nn.ReLU())
self.rcnn_cls_layer = nn.Sequential(
nn.Conv1d(256, 256, kernel_size=1, bias=False),
nn.BatchNorm1d(256), nn.ReLU(), nn.Dropout(0.3),
nn.Conv1d(256, 256, 1, bias=False), nn.BatchNorm1d(256), nn.ReLU(),
nn.Conv1d(256, 1, 1, stride=1, bias=True))
self.rcnn_reg_layer = nn.Sequential(
nn.Conv1d(256, 256, 1, stride=1, bias=False), nn.BatchNorm1d(256),
nn.ReLU(), nn.Dropout(0.3),
nn.Conv1d(256, 256, 1, stride=1, bias=False), nn.BatchNorm1d(256),
nn.ReLU(), nn.Conv1d(256, 7, 1, stride=1, bias=True))
self.voxel_size = [0.05, 0.05, 0.1]
self.point_cloud_range = [0, -40.0, -3.0, 70.4, 40.0, 1.0]
self.anchors = self.get_anchor()
def __init__(self, model_cfg, **kwargs):
super(PV_ENcoNet_POOLING_SC2, self).__init__()
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
device = self.device
self.model_cfg = model_cfg
self.num_neighbors = self.model_cfg.NUM_NEIGHBORS
self.decimation = self.model_cfg.DECIMATION
self.d_in = self.model_cfg.D_IN
norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
self.use_rgb = self.model_cfg.USE_RGB
self.use_nbg = self.model_cfg.USE_NBG
self.randla_encoder = LocalFeatureAggregation(self.d_in, 16,
self.num_neighbors,
device, self.use_rgb)
## (B,N,32,1)
self.sparse_shape = [41, 1600, 1408]
self.conv_input = spconv.SparseSequential(
spconv.SubMConv3d(38,
32,
3,
padding=1,
bias=False,
indice_key='subm1'),
norm_fn(32),
nn.ReLU(),
)
block = post_act_block
self.conv1 = spconv.SparseSequential(
block(32, 32, 3, norm_fn=norm_fn, padding=1, indice_key='subm1'), )
self.conv2 = spconv.SparseSequential(
# [1600, 1408, 41] <- [800, 704, 21]
block(32,
48,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv2',
conv_type='spconv'),
block(48, 48, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
block(48, 48, 3, norm_fn=norm_fn, padding=1, indice_key='subm2'),
)
self.conv3 = spconv.SparseSequential(
# [800, 704, 21] <- [400, 352, 11]
block(48,
64,
3,
norm_fn=norm_fn,
stride=2,
padding=1,
indice_key='spconv3',
conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm3'),
)
self.conv4 = spconv.SparseSequential(
# [400, 352, 11] <- [200, 176, 5]
block(64,
64,
3,
norm_fn=norm_fn,
stride=2,
padding=(0, 1, 1),
indice_key='spconv4',
conv_type='spconv'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
block(64, 64, 3, norm_fn=norm_fn, padding=1, indice_key='subm4'),
)
last_pad = 0
last_pad = self.model_cfg.get('last_pad', last_pad)
self.conv_out = spconv.SparseSequential(
# [200, 150, 5] -> [200, 150, 2]
spconv.SparseConv3d(64,
128, (3, 1, 1),
stride=(2, 1, 1),
padding=last_pad,
bias=False,
indice_key='spconv_down2'),
norm_fn(128),
nn.ReLU(),
)
self.device = device
self.num_point_features = 128
self = self.to(device)
def conv1x1(in_planes, out_planes, stride=1, indice_key=None):
return spconv.SubMConv3d(in_planes, out_planes, kernel_size=1, stride=stride,
padding=1, bias=False, indice_key=indice_key)
def conv1x1x3(in_planes, out_planes, stride=1, indice_key=None):
return spconv.SubMConv3d(in_planes, out_planes, kernel_size=(1, 1, 3), stride=stride,
padding=(0, 0, 1), bias=False, indice_key=indice_key)
def __init__(self,
output_shape,
use_norm=True,
num_input_features=128,
nclasses=20,
n_height=32,
strict=False,
init_size=16):
super(Spconv_alsaNet_res, self).__init__()
self.nclasses = nclasses
self.nheight = n_height
self.strict = False
sparse_shape = np.array(output_shape)
# sparse_shape[0] = 11
print(sparse_shape)
self.sparse_shape = sparse_shape
self.downCntx = ResContextBlock(num_input_features,
init_size,
indice_key="pre")
# self.resBlock1 = ResBlock(init_size, init_size, 0.2, pooling=True, height_pooling=True, indice_key="down1")
self.resBlock2 = ResBlock(init_size,
2 * init_size,
0.2,
height_pooling=True,
indice_key="down2")
self.resBlock3 = ResBlock(2 * init_size,
4 * init_size,
0.2,
height_pooling=True,
indice_key="down3")
self.resBlock4 = ResBlock(4 * init_size,
8 * init_size,
0.2,
pooling=True,
height_pooling=False,
indice_key="down4")
self.resBlock5 = ResBlock(8 * init_size,
16 * init_size,
0.2,
pooling=True,
height_pooling=False,
indice_key="down5")
# self.resBlock6 = ResBlock(16 * init_size, 16 * init_size, 0.2, pooling=False, height_pooling=False, indice_key="down6")
# self.ReconNet = ReconBlock(16 * init_size, 16 * init_size, indice_key="recon")
self.upBlock0 = UpBlock(16 * init_size,
16 * init_size,
indice_key="up0",
up_key="down5")
self.upBlock1 = UpBlock(16 * init_size,
8 * init_size,
indice_key="up1",
up_key="down4")
self.upBlock2 = UpBlock(8 * init_size,
4 * init_size,
indice_key="up2",
up_key="down3")
self.upBlock3 = UpBlock(4 * init_size,
2 * init_size,
indice_key="up3",
up_key="down2")
# self.upBlock4 = UpBlock(4 * init_size, 2 * init_size, indice_key="up4", up_key="down2")
# self.upBlock5 = UpBlock(2 * init_size, init_size, indice_key="up5", up_key="down1")
self.ReconNet = ReconBlock(2 * init_size,
2 * init_size,
indice_key="recon")
self.logits = spconv.SubMConv3d(4 * init_size,
nclasses,
indice_key="logit",
kernel_size=3,
stride=1,
padding=1,
bias=True)
