def __init__(self,
in_channels,
out_channels,
use_norm=True,
last_layer=False):
"""
Pillar Feature Net Layer.
The Pillar Feature Net could be composed of a series of these layers, but the PointPillars paper results only
used a single PFNLayer. This layer performs a similar role as second.pytorch.voxelnet.VFELayer.
:param in_channels: <int>. Number of input channels.
:param out_channels: <int>. Number of output channels.
:param use_norm: <bool>. Whether to include BatchNorm.
:param last_layer: <bool>. If last_layer, there is no concatenation of features.
"""
super().__init__()
self.name = 'GCNLayer'
self.last_vfe = last_layer
if not self.last_vfe:
out_channels = out_channels // 2
self.units = out_channels
if use_norm:
BatchNorm2d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm2d)
Conv2d = change_default_args(kernel_size=1, bias=False)(nn.Conv2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(kernel_size=1, bias=True)(nn.Conv2d)
self.seq = nn.Sequential(Conv2d(in_channels, self.units),
BatchNorm2d(self.units),
nn.LeakyReLU(negative_slope=0.2))
self.k = 8
def __init__(self,
in_channels,
out_channels,
use_norm=True,
last_layer=False):
"""
Pillar Feature Net Layer. Add batch size to fit tensorrt
Modified batchnorm 1d -> 2d to fit tensorrt
:param in_channels: <int>. Number of input channels.
:param out_channels: <int>. Number of output channels.
:param use_norm: <bool>. Whether to include BatchNorm.
:param last_layer: <bool>. If last_layer, there is no concatenation of features.
"""
super().__init__()
self.name = 'PFNLayer'
self.last_vfe = last_layer
if not self.last_vfe:
out_channels = out_channels // 2
self.units = out_channels
if use_norm:
# Have to use BatchNorm2d since 1d, 1, 1200000, 64 , 1200000is too long
BatchNorm1d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm2d)
# Linear = change_default_args(bias=False)(nn.Linear)
Conv = change_default_args(bias=False)(nn.Conv2d)
else:
BatchNorm1d = Empty
# Linear = change_default_args(bias=True)(nn.Linear)
Conv = change_default_args(bias=False)(nn.Conv2d)
self.norm = BatchNorm1d(self.units)
self.conv = Conv(in_channels, self.units, 1)
# replace max
self.dilaconv = Conv(self.units, self.units, (1, 34), dilation=(1, 3))
def __init__(self,
in_channels,
out_channels,
use_norm=True,
last_layer=False):
"""
Pillar Feature Net Layer.
The Pillar Feature Net could be composed of a series of these layers, but the PointPillars paper results only
used a single PFNLayer. This layer performs a similar role as second.pytorch.voxelnet.VFELayer.
:param in_channels: <int>. Number of input channels.
:param out_channels: <int>. Number of output channels.
:param use_norm: <bool>. Whether to include BatchNorm.
:param last_layer: <bool>. If last_layer, there is no concatenation of features.
"""
super().__init__()
self.name = 'PFNLayer'
self.last_vfe = last_layer
if not self.last_vfe:
out_channels = out_channels // 2
self.units = out_channels
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)
self.linear = Linear(in_channels, self.units)
self.norm = BatchNorm1d(self.units)
def __init__(self,
output_shape,
use_norm=True,
num_input_features=128,
num_filters_down1=[64],
num_filters_down2=[64, 64],
name='MiddleExtractor'):
super(MiddleExtractor, self).__init__()
self.name = name
if use_norm:
BatchNorm3d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm3d)
# BatchNorm3d = change_default_args(
# group=32, eps=1e-3, momentum=0.01)(GroupBatchNorm3d)
Conv3d = change_default_args(bias=False)(nn.Conv3d)
else:
BatchNorm3d = Empty
Conv3d = change_default_args(bias=True)(nn.Conv3d)
self.voxel_output_shape = output_shape
self.middle_conv = Sequential(
ZeroPad3d(1),
Conv3d(num_input_features, 64, 3, stride=(2, 1, 1)),
BatchNorm3d(64),
nn.ReLU(),
ZeroPad3d([1, 1, 1, 1, 0, 0]),
Conv3d(64, 64, 3, stride=1),
BatchNorm3d(64),
nn.ReLU(),
ZeroPad3d(1),
Conv3d(64, 64, 3, stride=(2, 1, 1)),
BatchNorm3d(64),
nn.ReLU(),
)
def __init__(self, num_input_features,num_out_features=320,activation="relu"):
super(VxNet, self).__init__()
#[40,1600,1408]
self.activation_fcn=change_default_args(inplace=True)(nn.ReLU)
if activation=="lrelu":
self.activation_fcn=change_default_args(negative_slope=0.1,inplace=True)(nn.LeakyReLU)
if activation=="mish":
self.activation_fcn=Mish
self.extra_conv = spconv.SparseSequential(
SpConv3d(64,num_out_features, 1,1), # shape no change
BatchNorm1d(num_out_features),
self.activation_fcn())
self.conv0 = double_conv(num_input_features, 16, 'subm0',activation=self.activation_fcn)
self.down0 = stride_conv(16, 32, 'down0',activation=self.activation_fcn)
self.conv1 = double_conv(32, 32, 'subm1',activation=self.activation_fcn) #[20,800,704]
self.down1 = stride_conv(32, 64, 'down1',activation=self.activation_fcn)
self.conv2 = triple_conv(64, 64, 'subm2',activation=self.activation_fcn) #[10,400,352]
self.down2 = stride_conv(64, 64, 'down2',activation=self.activation_fcn)
self.conv3 = triple_conv(64, 64, 'subm3',activation=self.activation_fcn) # #[5,200,176]
num_out_features=int(num_out_features/5)
self.point_fc = nn.Linear(160, 64, bias=False)
self.point_cls = nn.Linear(64, 1, bias=False)
self.point_reg = nn.Linear(64, 3, bias=False)
def __init__(self,
num_input_features=4,
use_norm=True,
num_filters=[32, 128],
with_distance=False,
voxel_size=(0.2, 0.2, 4),
pc_range=(0, -40, -3, 70.4, 40, 1),
name='VoxelFeatureExtractor'):
super(VoxelFeatureExtractorV2, 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)
assert len(num_filters) > 0
num_input_features += 3
if with_distance:
num_input_features += 1
self._with_distance = with_distance
num_filters = [num_input_features] + num_filters
filters_pairs = [[num_filters[i], num_filters[i + 1]]
for i in range(len(num_filters) - 1)]
self.vfe_layers = nn.ModuleList(
[VFELayer(i, o, use_norm) for i, o in filters_pairs])
self.linear = Linear(num_filters[-1], num_filters[-1])
# var_torch_init(self.linear.weight)
# var_torch_init(self.linear.bias)
self.norm = BatchNorm1d(num_filters[-1])
def __init__(self,
num_input_features=4,
use_norm=True,
num_filters=[32, 128],
with_distance=False,
voxel_size=(0.2, 0.2, 4),
pc_range=(0, -40, -3, 70.4, 40, 1),
name='VoxelFeatureExtractor'):
super(VoxelFeatureExtractor, 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)
assert len(num_filters) == 2
num_input_features += 3 # add mean features
if with_distance:
num_input_features += 1
self._with_distance = with_distance
self.vfe1 = VFELayer(num_input_features, num_filters[0], use_norm)
self.vfe2 = VFELayer(num_filters[0], num_filters[1], use_norm)
self.linear = Linear(num_filters[1], num_filters[1])
# var_torch_init(self.linear.weight)
# var_torch_init(self.linear.bias)
self.norm = BatchNorm1d(num_filters[1])
def __init__(self,
num_input_features=4,
use_norm=True,
num_filters=(0, 64),
with_distance=False,
voxel_size=(0.2, 0.2, 4),
pc_range=(0, -40, -3, 70.4, 40, 1)):
super(SingleVEN, self).__init__()
self.name = 'SingleVEN'
assert len(num_filters) == 2
num_input_features += 3 # add mean features
num_input_features += 3 # add offsets features
drop_rate = num_filters[0] / 100
assert 0 <= drop_rate <= 1
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)
self.linear = Linear(num_input_features, num_filters[1])
self.norm = BatchNorm1d(num_filters[1])
self.drop = nn.Dropout(drop_rate)
self.vx = voxel_size[0]
self.vy = voxel_size[1]
self.vz = voxel_size[1]
self.x_offset = self.vx / 2 + pc_range[0]
self.y_offset = self.vy / 2 + pc_range[1]
self.z_offset = self.vz / 2 + pc_range[2]
def __init__(self,
num_input_features=4,
use_norm=None,
num_filters=None,
with_distance=None,
name='PointnetFeatureExtractor'):
super(PointnetFeatureExtractor, self).__init__()
self.name = name
self.num_input_features = num_input_features
Conv1d = change_default_args(bias=False)(torch.nn.Conv1d)
Conv2d = change_default_args(bias=False)(torch.nn.Conv2d)
k = 8
self.knn1 = knn.KNearestNeighbor(k)
self.conv1 = Conv2d(3, 32, [k, 1])
self.bn1 = torch.nn.BatchNorm2d(32)
#
self.conv2 = Conv1d(32, 64, 1)
self.bn2 = torch.nn.BatchNorm1d(64)
#
self.knn3 = knn.KNearestNeighbor(k)
self.conv3 = Conv2d(64, 96, [k, 1])
self.bn3 = torch.nn.BatchNorm2d(96)
#
self.conv4 = Conv1d(96, 127, 1)
self.bn4 = torch.nn.BatchNorm1d(127)
def __init__(self, arg_dict):
super(HeadBase, self).__init__()
self.in_key = arg_dict['in_key']
self.out_key = arg_dict['out_key']
self.in_channel = int(arg_dict['in_channel'])
self.out_channel = int(arg_dict['out_channel'])
self.block_num = int(arg_dict['block_num'])
assert self.block_num > 0, "minimum block number is one"
self.se_mode = arg_dict['se_mode']
self.use_norm = True if arg_dict['use_norm'] == 'True' else False
if self.use_norm:
SubMConv3d = change_default_args(bias=False)(spconv.SubMConv3d)
else:
SubMConv3d = change_default_args(bias=True)(spconv.SubMConv3d)
for index in range(self.block_num):
block = BasicBlock(self.in_channel,
self.in_channel,
2,
f'subm_{id(self)}',
self.se_mode,
use_norm=self.use_norm)
self.add_module(f'block_{index}', block)
self.post_block = spconv.SparseSequential(
SubMConv3d(self.in_channel, self.out_channel, 1))
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,
num_input_features,
use_norm=True):
super(DepConvNet3, self).__init__()
if use_norm:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm2d)
BatchNorm1d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
else:
BatchNorm2d = nn.Empty
BatchNorm1d = nn.Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
# 512 * 64 * 512
self.conv1 = DepConv3D(num_input_features, 16, 3, padding=1)
self.bn1 = BatchNorm2d(16)
self.conv2 = DepConv3D(16, 16, 3, padding=1)
self.bn2 = BatchNorm2d(16)
# self.conv3 = DepConv3D(16, 16, 3, padding=1) # 512 * 64 * 256
# self.bn3 = BatchNorm2d(16)
# self.conv4 = DepConv3D(16, 16, 3, padding=1)
# self.bn4 = BatchNorm2d(16)
# self.conv16 = DepConv3D(16, 16, 3, padding=1)
# self.bn16 = BatchNorm2d(16)
self.conv5 = DepConv3D_v2(16, 32, 3, (2,2,2), padding=1, subm=True) # 256 * 32 * 128
self.bn5 = BatchNorm2d(32)
self.conv6 = DepConv3D_v2(32, 32, 3, padding=1, subm=False)
self.bn6 = BatchNorm2d(32)
self.conv7 = DepConv3D_v2(32, 32, 3, padding=1, subm=True)
self.bn7 = BatchNorm2d(32)
# self.conv8 = DepConv3D(32, 32, 3, padding=1)
# self.bn8 = BatchNorm2d(32)
self.conv9 = DepConv3D_v2(32, 64, 3, (2,2,2), padding=1, subm=True) # 128, 32, 64
self.bn9 = BatchNorm2d(64)
self.conv20 = DepConv3D_v2(64, 64, 3, padding=1, subm=False)
self.bn20 = BatchNorm2d(64)
self.conv21 = DepConv3D_v2(64, 64, 3, padding=1, subm=False)
self.bn21 = BatchNorm2d(64)
self.conv22 = DepConv3D_v2(64, 64, 3, padding=1, subm=False)
self.bn22 = BatchNorm2d(64)
self.conv11 = DepConv3D_v2(64, 64, 3, (2,1,2), padding=1, subm=True)# 64, 16, 64
self.bn11 = BatchNorm2d(64)
self.conv12 = DepConv3D_v2(64, 64, 3, padding=1, subm=False) # 8 * 32 * 64
self.bn12 = BatchNorm2d(64)
self.conv13 = DepConv3D_v2(64, 64, 3, padding=1, subm=False) # 4
self.bn13 = BatchNorm2d(64)
# self.conv14 = DepConv3D(64, 64, 3, padding=1) # 2
# self.bn14 = BatchNorm2d(64)
self.conv15 = DepConv3D_v2(64, 64, 3, (1,1,1), padding=1,subm=False)
self.bn15 = BatchNorm2d(64)
self.conv16 = DepConv3D_v2(64, 64, 3, (1,1,1), padding=1,subm=False)
self.bn16 = BatchNorm2d(64)
# self.conv17 = DepConv3D(64, 64, 3, (1,2,1), padding=1)
# self.bn17 = BatchNorm2d(64)
self.count = 0
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', sparse_shape) # [11, H, W]
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(scn.SubmanifoldConvolution(3, i, o, 3, False))
middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99))
middle_layers.append(
scn.Convolution(3,
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(
scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99))
# 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(scn.SubmanifoldConvolution(3, i, o, 3, False))
middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99))
middle_layers.append(
scn.Convolution(3,
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(
scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99))
middle_layers.append(scn.SparseToDense(3, num_filters[-1]))
self.middle_conv = Sequential(*middle_layers)
def __init__(self,
output_shape,
use_norm=True,
num_input_features=128,
num_filters_down1=[64],
num_filters_down2=[64, 64],
name='SpResNetD4HD'):
super(SpResNetD4HD, self).__init__()
self.name = name
if use_norm:
BatchNorm2d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm2d)
BatchNorm1d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
SpConv3d = change_default_args(bias=False)(spconv.SparseConv3d)
SubMConv3d = change_default_args(bias=False)(spconv.SubMConv3d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
BatchNorm2d = Empty
BatchNorm1d = Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
SpConv3d = change_default_args(bias=True)(spconv.SparseConv3d)
SubMConv3d = change_default_args(bias=True)(spconv.SubMConv3d)
ConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0]
# sparse_shape[0] = 11
print(sparse_shape)
self.sparse_shape = sparse_shape
self.voxel_output_shape = output_shape
# num_input_features = 4
self.middle_conv = spconv.SparseSequential(
SubMConv3d(num_input_features, 32, 3, indice_key="res0"),
BatchNorm1d(32),
nn.ReLU(),
SparseBasicBlock(32, 32, indice_key="res0"),
SparseBasicBlock(32, 32, indice_key="res0"),
SpConv3d(32, 64, 3, 2,
padding=1), # [800, 600, 21] -> [400, 300, 11]
BatchNorm1d(64),
nn.ReLU(),
SparseBasicBlock(64, 64, indice_key="res1"),
SparseBasicBlock(64, 64, indice_key="res1"),
SpConv3d(64, 64, 3, 2,
padding=[0, 1, 1]), # [400, 300, 11] -> [200, 150, 5]
BatchNorm1d(64),
nn.ReLU(),
SparseBasicBlock(64, 64, indice_key="res2"),
SparseBasicBlock(64, 64, indice_key="res2"),
SpConv3d(64, 64, (3, 1, 1),
(2, 1, 1)), # [200, 150, 5] -> [200, 150, 2]
BatchNorm1d(64),
nn.ReLU(),
)
def __init__(self,
in_c,
out_c,
layer_number=2,
indice_key=None,
se_mode='none',
use_norm=True):
super(BasicBlock, self).__init__()
assert layer_number > 1, "minimum number of layers is 2"
self.in_c = in_c
self.out_c = out_c
self.layer_number = layer_number
self.indice_key = indice_key if indice_key is not None else id(self)
self.se = None
if se_mode != 'none':
c = max(8, int(round(self.out_c / 16.0)))
self.se = SE_Block(self.out_c, c, se_mode)
if use_norm:
BatchNorm1d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm1d)
SubMConv3d = change_default_args(bias=False)(spconv.SubMConv3d)
else:
BatchNorm1d = Empty
SubMConv3d = change_default_args(bias=True)(spconv.SubMConv3d)
self.conv = spconv.SparseSequential()
self.conv.add(
spconv.SparseSequential(
SubMConv3d(self.in_c,
self.out_c,
3,
indice_key=self.indice_key),
BatchNorm1d(self.out_c),
nn.ReLU(inplace=True),
))
for l in range(self.layer_number - 2):
self.conv.add(
spconv.SparseSequential(
SubMConv3d(self.out_c,
self.out_c,
3,
indice_key=self.indice_key),
BatchNorm1d(self.out_c), nn.ReLU(inplace=True)))
self.conv.add(
spconv.SparseSequential(
SubMConv3d(self.out_c,
self.out_c,
3,
indice_key=self.indice_key),
BatchNorm1d(self.out_c)))
self.conv1x1 = spconv.SparseSequential(
SubMConv3d(self.in_c, self.out_c, 1), BatchNorm1d(self.out_c))
def __init__(self,
sparse_shape,
in_channels=128,
out_channels=128,
activation="relu",
name='SpMiddleFHD'):
super(SpMiddleFHD, self).__init__()
self.name = name
print("input sparse shape is ", sparse_shape)
self.sparse_shape = sparse_shape
self.voxel_output_shape = sparse_shape
self.activation_fcn = change_default_args(inplace=True)(nn.ReLU)
if activation == "lrelu":
self.activation_fcn = change_default_args(negative_slope=0.1,
inplace=True)(
nn.LeakyReLU)
if activation == "mish":
self.activation_fcn = Mish
# input: # [1600, 1200, 40]
self.conv0 = double_conv(in_channels,
16,
'subm0',
activation=self.activation_fcn)
self.down0 = stride_conv(16,
32,
'down0',
activation=self.activation_fcn)
self.conv1 = double_conv(
32, 32, 'subm1', activation=self.activation_fcn) # [20,800,704]
self.down1 = stride_conv(32,
64,
'down1',
activation=self.activation_fcn)
self.conv2 = triple_conv(
64, 64, 'subm2', activation=self.activation_fcn) # [10,400,352]
self.down2 = stride_conv(64,
64,
'down2',
activation=self.activation_fcn)
self.conv3 = triple_conv(64,
64,
'subm3',
activation=self.activation_fcn) # [5,200,176]
self.down3 = spconv.SparseSequential(
SpConv3d(64, 64, (3, 1, 1), (2, 1, 1), indice_key="down3"),
BatchNorm1d(64), self.activation_fcn()) # [2,200,176]
def __init__(self,
output_shape,
use_norm=True,
num_input_features=256,
num_filters_down1=[64],
num_filters_down2=[64, 64],
name='SpMiddleVision'):
super(SpMiddleVision, self).__init__()
self.name = name
if use_norm:
BatchNorm2d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm2d)
BatchNorm1d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
SpConv3d = change_default_args(bias=False)(spconv.SparseConv3d)
SubMConv3d = change_default_args(bias=False)(spconv.SubMConv3d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
BatchNorm2d = Empty
BatchNorm1d = Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
SpConv3d = change_default_args(bias=True)(spconv.SparseConv3d)
SubMConv3d = change_default_args(bias=True)(spconv.SubMConv3d)
ConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0]
# sparse_shape[0] = 11
print("sparse_shape:", sparse_shape)
self.sparse_shape = sparse_shape
self.voxel_output_shape = output_shape
# input: # [1600, 1200, 41]
self.middle_conv = spconv.SparseSequential(
SpConv3d(
num_input_features, 256, 3, 2, padding=1
), # [1600, 1200, 41] -> [800, 600, 21], original stride is 2, large_voxel 1
#32
BatchNorm1d(256),
nn.ReLU(),
SpConv3d(
256, 256, 3, 2, padding=1
), # [800, 600, 21] -> [400, 300, 11], original stride is 2, large_voxel 1
#64
BatchNorm1d(256),
nn.ReLU(),
SpConv3d(256, 256, 3, 2,
padding=[0, 1, 1]), # [400, 300, 11] -> [200, 150, 5]
#64
BatchNorm1d(256),
nn.ReLU(),
)
self.max_batch_size = 6
def __init__(self, in_channels, out_channels, use_norm=True, name='vfe'):
super(VFELayer, self).__init__()
self.name = name
self.units = int(out_channels / 2)
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)
self.linear = Linear(in_channels, self.units)
self.norm = BatchNorm1d(self.units)
def _make_layer(self, inplanes, planes, num_blocks, stride=1):
if self._use_switchnorm:
BatchNorm2d = SwitchNorm2d
Conv2d = change_default_args(bias=False)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
elif self._use_norm:
if self._use_groupnorm:
BatchNorm2d = change_default_args(num_groups=self._num_groups,
eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)(
nn.BatchNorm2d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
block = Sequential(
nn.ZeroPad2d(1),
Conv2d(inplanes, planes, 3, stride=stride),
BatchNorm2d(planes),
nn.ReLU(),
)
for j in range(num_blocks):
block.add(Conv2d(planes, planes, 3, padding=1))
block.add(BatchNorm2d(planes))
block.add(nn.ReLU())
return block, planes
def _make_layer(self, inplanes, planes, num_blocks, idx, stride=1):
if self._use_norm:
if self._use_groupnorm:
SparseBatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
DenseBatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
else:
SparseBatchNorm2d = change_default_args(eps=1e-3,
momentum=0.01)(
nn.BatchNorm1d)
DenseBatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm2d)
SparseConv2d = change_default_args(bias=False)(spconv.SparseConv2d)
DenseConv2d = change_default_args(bias=False)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=False)(
spconv.SparseConvTranspose2d)
else:
SparseBatchNorm2d = Empty
DenseBatchNorm2d = Empty
SparseConv2d = change_default_args(bias=True)(spconv.SparseConv2d)
DenseConv2d = change_default_args(bias=True)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=True)(
spconv.SparseConvTranspose2d)
print("STRIDE:", stride)
if idx <= LAST_SPARSE_IDX:
block = spconv.SparseSequential(
SparseZeroPad2d(1),
SparseConv2d(inplanes, planes, 3, stride=stride),
SparseBatchNorm2d(planes),
nn.ReLU(),
)
for j in range(num_blocks):
block.add(SparseConv2d(planes, planes, 3, padding=1))
block.add(SparseBatchNorm2d(planes))
block.add(nn.ReLU())
else:
block = Sequential(
nn.ZeroPad2d(1),
DenseConv2d(inplanes, planes, 3, stride=stride),
DenseBatchNorm2d(planes),
nn.ReLU(),
)
for j in range(num_blocks):
block.add(DenseConv2d(planes, planes, 3, padding=1))
block.add(DenseBatchNorm2d(planes))
block.add(nn.ReLU())
return block, planes
def _make_layer(self, inplanes, planes, num_blocks, idx, stride=1):
print("NUM BLOCKS:", num_blocks)
if self._use_norm:
if self._use_groupnorm:
BatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(spconv.SparseConv2d)
SubMConv2d = change_default_args(bias=False)(spconv.SubMConv2d)
ConvTranspose2d = change_default_args(bias=False)(
spconv.SparseConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(spconv.SparseConv2d)
SubMConv2d = change_default_args(bias=True)(spconv.SubMConv2d)
ConvTranspose2d = change_default_args(bias=True)(
spconv.SparseConvTranspose2d)
block = spconv.SparseSequential(
SparseZeroPad2d(1),
# PrintLayer(0),
Conv2d(inplanes, planes, 3, stride=stride),
BatchNorm2d(planes),
nn.ReLU(),
# PrintLayer(1),
)
for j in range(num_blocks):
block.add(SubMConv2d(planes, planes, 3, padding=1))
block.add(BatchNorm2d(planes)),
block.add(nn.ReLU())
# block.add(PrintLayer(2 + j))
return block, planes
def _make_deblock(self, num_out_filters, idx):
stride = self._upsample_strides[idx - self._upsample_start_idx]
if self._use_norm:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(ME.MinkowskiBatchNorm)
Conv2d = change_default_args(bias=False, dimension=2)(ME.MinkowskiConvolution)
ConvTranspose2d = change_default_args(bias=False, dimension=2)(
ME.MinkowskiConvolutionTranspose)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True, dimension=2)(ME.MinkowskiConvolution)
ConvTranspose2d = change_default_args(bias=True, dimension=2)(
ME.MinkowskiConvolutionTranspose)
ReLU = ME.MinkowskiReLU()
if stride >= 1:
stride = np.round(stride).astype(np.int64)
print("DEBLOCK CONV_TRANSPOSE STRIDE:", stride)
deblock = Sequential(
# PrintLayer(stride),
ConvTranspose2d(
num_out_filters,
self._num_upsample_filters[idx - self._upsample_start_idx],
stride,
stride=stride),
# PrintLayer(stride),
BatchNorm2d(
self._num_upsample_filters[idx -
self._upsample_start_idx]),
ReLU,
)
else:
stride = np.round(1 / stride).astype(np.int64)
print("DEBLOCK CONV STRIDE:", stride)
deblock = Sequential(
# PrintLayer(stride),
Conv2d(
num_out_filters,
self._num_upsample_filters[idx - self._upsample_start_idx],
stride,
stride=stride),
# PrintLayer(stride),
BatchNorm2d(
self._num_upsample_filters[idx -
self._upsample_start_idx]),
ReLU,
)
return deblock
def _make_layer(self, inplanes, planes, num_blocks, stride=1):
BatchNorm2d = change_default_args(eps=1e-3,
momentum=0.01)(nn.BatchNorm2d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
block = Sequential(
Conv2d(inplanes, planes, 3, padding=1, stride=stride),
BatchNorm2d(planes), self.activation_fcn())
for j in range(num_blocks):
block.add(Conv2d(planes, planes, 3, padding=1, dilation=1))
block.add(BatchNorm2d(planes))
block.add(self.activation_fcn())
return block, planes
def _make_layer(self, inplanes, planes, num_blocks, idx, stride=1):
print("NUM BLOCKS:", num_blocks, "STRIDE:", stride)
if self._use_norm:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(ME.MinkowskiBatchNorm)
Conv2d = change_default_args(bias=False, dimension=2)(ME.MinkowskiConvolution)
SubMConv2d = change_default_args(bias=False, dimension=2)(ME.MinkowskiConvolution)
ConvTranspose2d = change_default_args(bias=False, dimension=2)(
ME.MinkowskiConvolutionTranspose)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True, dimension=2)(ME.MinkowskiConvolution)
SubMConv2d = change_default_args(bias=True, dimension=2)(ME.MinkowskiConvolution)
ConvTranspose2d = change_default_args(bias=True, dimension=2)(
ME.MinkowskiConvolutionTranspose)
ReLU = ME.MinkowskiReLU()
block = Sequential(
# PrintLayer(0),
Conv2d(inplanes, planes, 2, stride=stride),
BatchNorm2d(planes),
ReLU,
# PrintLayer(1),
)
for j in range(num_blocks):
block.add(SubMConv2d(planes, planes, 3))
block.add(BatchNorm2d(planes)),
block.add(ReLU)
# block.add(PrintLayer(2 + j))
return block, planes
def _make_deblock(self, num_out_filters, idx):
print("CUSTOM MAKE DEBLOCK")
stride = self._upsample_strides[idx - self._upsample_start_idx]
if self._use_norm:
if self._use_groupnorm:
SparseBatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
DenseBatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
else:
SparseBatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(ME.MinkowskiBatchNorm)
DenseBatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm2d)
SparseConvTranspose2d = change_default_args(bias=False, dimension=2)(
ME.MinkowskiConvolutionTranspose)
DenseConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
SparseBatchNorm2d = Empty
DenseBatchNorm2d = Empty
SparseConvTranspose2d = change_default_args(bias=True, dimension=2)(
ME.MinkowskiConvolutionTranspose)
DenseConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
ReLU = ME.MinkowskiReLU()
stride = np.round(stride).astype(np.int64)
if (idx <= LAST_SPARSE_IDX):
deblock = Sequential(
SparseConvTranspose2d(
num_out_filters,
self._num_upsample_filters[idx - self._upsample_start_idx],
stride,
stride=stride),
SparseBatchNorm2d(
self._num_upsample_filters[idx -
self._upsample_start_idx]),
ReLU,
ME.ToDense()
)
else:
stride = np.round(stride).astype(np.int64)
deblock = Sequential(
DenseConvTranspose2d(
num_out_filters,
self._num_upsample_filters[idx - self._upsample_start_idx],
stride,
stride=stride),
DenseBatchNorm2d(
self._num_upsample_filters[idx -
self._upsample_start_idx]),
ReLU,
)
return deblock
def _make_layer(self, inplanes, planes, num_blocks, idx, stride=1):
print("NUM BLOCKS:", num_blocks, "STRIDE:", stride)
if self._use_norm:
if self._use_groupnorm:
BatchNorm2d = change_default_args(
num_groups=self._num_groups, eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(spconv.SparseConv2d)
SubMConv2d = change_default_args(bias=False)(spconv.SubMConv2d)
ConvTranspose2d = change_default_args(bias=False)(
spconv.SparseConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(spconv.SparseConv2d)
SubMConv2d = change_default_args(bias=True)(spconv.SubMConv2d)
ConvTranspose2d = change_default_args(bias=True)(
spconv.SparseConvTranspose2d)
block = spconv.SparseSequential()
wide_conv_schedule = [None, 7, 9]
filter_radius = wide_conv_schedule[idx]
if filter_radius is not None:
print("Filter radius:", filter_radius)
block.add(SubMConv2d(inplanes, inplanes, filter_radius))
# Substitute for later convs.
num_blocks -= 1
block.add(Conv2d(inplanes, planes, 2, stride=stride))
block.add(BatchNorm2d(planes))
block.add(nn.ReLU())
for j in range(num_blocks):
block.add(SubMConv2d(planes, planes, 3, padding=1))
block.add(BatchNorm2d(planes)),
block.add(nn.ReLU())
# block.add(PrintLayer(2 + j))
return block, planes
def _make_deblock(self, num_out_filters, idx):
stride = self._upsample_strides[idx - self._upsample_start_idx]
if self._use_norm:
if self._use_groupnorm:
BatchNorm2d = change_default_args(num_groups=self._num_groups,
eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)(
nn.BatchNorm1d)
Conv2d = change_default_args(bias=False)(spconv.SparseConv2d)
ConvTranspose2d = change_default_args(bias=False)(
spconv.SparseConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(spconv.SparseConv2d)
ConvTranspose2d = change_default_args(bias=True)(
spconv.SparseConvTranspose2d)
if stride >= 1:
stride = np.round(stride).astype(np.int64)
print("DEBLOCK CONV_TRANSPOSE STRIDE:", stride)
deblock = spconv.SparseSequential(
# PrintLayer(stride),
ConvTranspose2d(
num_out_filters,
self._num_upsample_filters[idx - self._upsample_start_idx],
stride,
stride=stride),
# PrintLayer(stride),
BatchNorm2d(
self._num_upsample_filters[idx - self._upsample_start_idx]
),
nn.ReLU(),
)
else:
stride = np.round(1 / stride).astype(np.int64)
print("DEBLOCK CONV STRIDE:", stride)
deblock = spconv.SparseSequential(
# PrintLayer(stride),
Conv2d(num_out_filters,
self._num_upsample_filters[idx -
self._upsample_start_idx],
stride,
stride=stride),
# PrintLayer(stride),
BatchNorm2d(
self._num_upsample_filters[idx - self._upsample_start_idx]
),
nn.ReLU(),
)
deblock.add(spconv.ToDense())
return deblock
def __init__(self,
input_channels,
use_norm,
num_anchor_per_loc,
encode_background_as_zeros,
num_class,
box_code_size,
use_direction_classifier,
name="RCNN"):
super(RCNN, self).__init__()
self._num_anchor_per_loc = num_anchor_per_loc
self._num_cls = num_class
self._encode_background_as_zeros = encode_background_as_zeros
self._use_direction_cls = use_direction_classifier
self._use_direction_classifier = use_direction_classifier
self._box_code_size = box_code_size
if encode_background_as_zeros:
num_cls = num_class
else:
num_cls = (num_class + 1)
if use_norm:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm2d)
else:
BatchNorm2d = Empty
self.input_channels = input_channels
self.fc_layer1 = nn.Conv2d(input_channels * 7 * 7, 1024, 1)
self.norm_layer1 = BatchNorm2d(1024)
self.relu_layer1 = torch.nn.ReLU(inplace=False)
self.fc_layer2 = nn.Conv2d(1024, 512, 1)
self.norm_layer2 = BatchNorm2d(512)
self.relu_layer2 = torch.nn.ReLU(inplace=False)
self.conv_cls = nn.Conv2d(512, num_cls, 1)
self.conv_box = nn.Conv2d(512, box_code_size, 1)
if use_direction_classifier:
self.conv_dir_cls = nn.Conv2d(512, 2, 1)
def __init__(self,
use_norm=True,
num_class=2,
layer_nums=[3, 5, 5],
layer_strides=[2, 2, 2],
num_filters=[128, 128, 256],
upsample_strides=[1, 2, 4],
num_upsample_filters=[256, 256, 256],
num_input_filters=128,
num_anchor_per_loc=2,
encode_background_as_zeros=True,
use_direction_classifier=True,
use_groupnorm=False,
num_groups=32,
use_bev=False,
box_code_size=7,
name='psa'):
"""
:param use_norm:
:param num_class:
:param layer_nums:
:param layer_strides:
:param num_filters:
:param upsample_strides:
:param num_upsample_filters:
:param num_input_filters:
:param num_anchor_per_loc:
:param encode_background_as_zeros:
:param use_direction_classifier:
:param use_groupnorm:
:param num_groups:
:param use_bev:
:param box_code_size:
:param name:
"""
super(PSA, self).__init__()
self._num_anchor_per_loc = num_anchor_per_loc ## 2
self._use_direction_classifier = use_direction_classifier # True
self._use_bev = use_bev # False
assert len(layer_nums) == 3
assert len(layer_strides) == len(layer_nums)
assert len(num_filters) == len(layer_nums)
assert len(upsample_strides) == len(layer_nums)
assert len(num_upsample_filters) == len(layer_nums)
factors = []
for i in range(len(layer_nums)):
assert int(np.prod(
layer_strides[:i + 1])) % upsample_strides[i] == 0
factors.append(
np.prod(layer_strides[:i + 1]) // upsample_strides[i])
assert all([x == factors[0] for x in factors])
if use_norm: # True
if use_groupnorm:
BatchNorm2d = change_default_args(num_groups=num_groups,
eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(eps=1e-3, momentum=0.01)(
nn.BatchNorm2d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
# note that when stride > 1, conv2d with same padding isn't
# equal to pad-conv2d. we should use pad-conv2d.
block2_input_filters = num_filters[0]
if use_bev:
self.bev_extractor = Sequential(
Conv2d(6, 32, 3, padding=1),
BatchNorm2d(32),
nn.ReLU(),
# nn.MaxPool2d(2, 2),
Conv2d(32, 64, 3, padding=1),
BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(2, 2),
)
block2_input_filters += 64
self.block1 = Sequential(
nn.ZeroPad2d(1),
Conv2d(num_input_filters,
num_filters[0],
3,
stride=layer_strides[0]),
BatchNorm2d(num_filters[0]),
nn.ReLU(),
)
for i in range(layer_nums[0]):
self.block1.add(
Conv2d(num_filters[0], num_filters[0], 3, padding=1))
self.block1.add(BatchNorm2d(num_filters[0]))
self.block1.add(nn.ReLU())
self.deconv1 = Sequential(
ConvTranspose2d(num_filters[0],
num_upsample_filters[0],
upsample_strides[0],
stride=upsample_strides[0]),
BatchNorm2d(num_upsample_filters[0]),
nn.ReLU(),
)
self.block2 = Sequential(
nn.ZeroPad2d(1),
Conv2d(block2_input_filters,
num_filters[1],
3,
stride=layer_strides[1]),
BatchNorm2d(num_filters[1]),
nn.ReLU(),
)
for i in range(layer_nums[1]):
self.block2.add(
Conv2d(num_filters[1], num_filters[1], 3, padding=1))
self.block2.add(BatchNorm2d(num_filters[1]))
self.block2.add(nn.ReLU())
self.deconv2 = Sequential(
ConvTranspose2d(num_filters[1],
num_upsample_filters[1],
upsample_strides[1],
stride=upsample_strides[1]),
BatchNorm2d(num_upsample_filters[1]),
nn.ReLU(),
)
self.block3 = Sequential(
nn.ZeroPad2d(1),
Conv2d(num_filters[1], num_filters[2], 3, stride=layer_strides[2]),
BatchNorm2d(num_filters[2]),
nn.ReLU(),
)
for i in range(layer_nums[2]):
self.block3.add(
Conv2d(num_filters[2], num_filters[2], 3, padding=1))
self.block3.add(BatchNorm2d(num_filters[2]))
self.block3.add(nn.ReLU())
self.deconv3 = Sequential(
ConvTranspose2d(num_filters[2],
num_upsample_filters[2],
upsample_strides[2],
stride=upsample_strides[2]),
BatchNorm2d(num_upsample_filters[2]),
nn.ReLU(),
)
if encode_background_as_zeros:
num_cls = num_anchor_per_loc * num_class
else:
num_cls = num_anchor_per_loc * (num_class + 1)
self.conv_cls = nn.Conv2d(sum(num_upsample_filters), num_cls, 1)
self.conv_box = nn.Conv2d(sum(num_upsample_filters),
num_anchor_per_loc * box_code_size, 1)
if use_direction_classifier:
self.conv_dir_cls = nn.Conv2d(sum(num_upsample_filters),
num_anchor_per_loc * 2, 1)
################### refine
self.bottle_conv = nn.Conv2d(sum(num_upsample_filters),
sum(num_upsample_filters) // 3, 1)
self.block1_dec2x = nn.MaxPool2d(kernel_size=2) ### C=64
self.block1_dec4x = nn.MaxPool2d(kernel_size=4) ### C=64
self.block2_dec2x = nn.MaxPool2d(kernel_size=2) ### C=128
self.block2_inc2x = ConvTranspose2d(
num_filters[1],
num_filters[0] // 2,
upsample_strides[1],
stride=upsample_strides[1]) ### C=32
self.block3_inc2x = ConvTranspose2d(
num_filters[2],
num_filters[1] // 2,
upsample_strides[1],
stride=upsample_strides[1]) #### C=64
self.block3_inc4x = ConvTranspose2d(
num_filters[2],
num_filters[0] // 2,
upsample_strides[2],
stride=upsample_strides[2]) #### C=32
self.fusion_block1 = nn.Conv2d(
num_filters[0] + num_filters[0] // 2 + num_filters[0] // 2,
num_filters[0], 1)
self.fusion_block2 = nn.Conv2d(
num_filters[0] + num_filters[1] + num_filters[1] // 2,
num_filters[1], 1)
self.fusion_block3 = nn.Conv2d(
num_filters[0] + num_filters[1] + num_filters[2], num_filters[2],
1)
self.refine_up1 = Sequential(
ConvTranspose2d(num_filters[0],
num_upsample_filters[0],
upsample_strides[0],
stride=upsample_strides[0]),
BatchNorm2d(num_upsample_filters[0]),
nn.ReLU(),
)
self.refine_up2 = Sequential(
ConvTranspose2d(num_filters[1],
num_upsample_filters[1],
upsample_strides[1],
stride=upsample_strides[1]),
BatchNorm2d(num_upsample_filters[1]),
nn.ReLU(),
)
self.refine_up3 = Sequential(
ConvTranspose2d(num_filters[2],
num_upsample_filters[2],
upsample_strides[2],
stride=upsample_strides[2]),
BatchNorm2d(num_upsample_filters[2]),
nn.ReLU(),
)
#######
C_Bottle = cfg.PSA.C_Bottle
C = cfg.PSA.C_Reudce
self.RF1 = Sequential( # 3*3
Conv2d(C_Bottle * 2, C, kernel_size=1, stride=1),
BatchNorm2d(C),
nn.ReLU(inplace=True),
Conv2d(C,
C_Bottle * 2,
kernel_size=3,
stride=1,
padding=1,
dilation=1),
BatchNorm2d(C_Bottle * 2),
nn.ReLU(inplace=True),
)
self.RF2 = Sequential( # 5*5
Conv2d(C_Bottle, C, kernel_size=3, stride=1, padding=1),
BatchNorm2d(C),
nn.ReLU(inplace=True),
Conv2d(C, C_Bottle, kernel_size=3, stride=1, padding=1,
dilation=1),
BatchNorm2d(C_Bottle),
nn.ReLU(inplace=True),
)
self.RF3 = Sequential( # 7*7
Conv2d(C_Bottle // 2, C, kernel_size=3, stride=1, padding=1),
BatchNorm2d(C),
nn.ReLU(inplace=True),
Conv2d(C, C, kernel_size=3, stride=1, padding=1),
BatchNorm2d(C),
nn.ReLU(inplace=True),
Conv2d(C, C_Bottle // 2, kernel_size=3, stride=1, padding=1),
BatchNorm2d(C_Bottle // 2),
nn.ReLU(inplace=True),
)
self.concat_conv1 = nn.Conv2d(num_filters[1],
num_filters[1],
kernel_size=3,
padding=1) ## kernel_size=3
self.concat_conv2 = nn.Conv2d(num_filters[1],
num_filters[1],
kernel_size=3,
padding=1)
self.concat_conv3 = nn.Conv2d(num_filters[1],
num_filters[1],
kernel_size=3,
padding=1)
self.refine_cls = nn.Conv2d(sum(num_upsample_filters), num_cls, 1)
self.refine_loc = nn.Conv2d(sum(num_upsample_filters),
num_anchor_per_loc * box_code_size, 1)
if use_direction_classifier:
self.refine_dir = nn.Conv2d(sum(num_upsample_filters),
num_anchor_per_loc * 2, 1)
def __init__(self,
use_norm=True,
num_class=2,
layer_nums=(3, 5, 5),
layer_strides=(2, 2, 2),
num_filters=(128, 128, 256),
upsample_strides=(1, 2, 4),
num_upsample_filters=(256, 256, 256),
num_input_features=128,
num_anchor_per_loc=2,
encode_background_as_zeros=True,
use_direction_classifier=True,
use_groupnorm=False,
num_groups=32,
box_code_size=7,
num_direction_bins=2,
name='rpn'):
"""deprecated. exists for checkpoint backward compilability (SECOND v1.0)
"""
super(RPN, self).__init__()
self._num_anchor_per_loc = num_anchor_per_loc
self._use_direction_classifier = use_direction_classifier
assert len(layer_nums) == 3
assert len(layer_strides) == len(layer_nums)
assert len(num_filters) == len(layer_nums)
assert len(upsample_strides) == len(layer_nums)
assert len(num_upsample_filters) == len(layer_nums)
upsample_strides = [
np.round(u).astype(np.int64) for u in upsample_strides
]
factors = []
for i in range(len(layer_nums)):
assert int(np.prod(
layer_strides[:i + 1])) % upsample_strides[i] == 0
factors.append(
np.prod(layer_strides[:i + 1]) // upsample_strides[i])
assert all([x == factors[0] for x in factors])
if use_norm:
if use_groupnorm:
BatchNorm2d = change_default_args(
num_groups=num_groups, eps=1e-3)(GroupNorm)
else:
BatchNorm2d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm2d)
Conv2d = change_default_args(bias=False)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=False)(
nn.ConvTranspose2d)
else:
BatchNorm2d = Empty
Conv2d = change_default_args(bias=True)(nn.Conv2d)
ConvTranspose2d = change_default_args(bias=True)(
nn.ConvTranspose2d)
# note that when stride > 1, conv2d with same padding isn't
# equal to pad-conv2d. we should use pad-conv2d.
block2_input_filters = num_filters[0]
self.block1 = Sequential(
nn.ZeroPad2d(1),
Conv2d(
num_input_features, num_filters[0], 3,
stride=layer_strides[0]),
BatchNorm2d(num_filters[0]),
nn.ReLU(),
)
for i in range(layer_nums[0]):
self.block1.add(
Conv2d(num_filters[0], num_filters[0], 3, padding=1))
self.block1.add(BatchNorm2d(num_filters[0]))
self.block1.add(nn.ReLU())
self.deconv1 = Sequential(
ConvTranspose2d(
num_filters[0],
num_upsample_filters[0],
upsample_strides[0],
stride=upsample_strides[0]),
BatchNorm2d(num_upsample_filters[0]),
nn.ReLU(),
)
self.block2 = Sequential(
nn.ZeroPad2d(1),
Conv2d(
block2_input_filters,
num_filters[1],
3,
stride=layer_strides[1]),
BatchNorm2d(num_filters[1]),
nn.ReLU(),
)
for i in range(layer_nums[1]):
self.block2.add(
Conv2d(num_filters[1], num_filters[1], 3, padding=1))
self.block2.add(BatchNorm2d(num_filters[1]))
self.block2.add(nn.ReLU())
self.deconv2 = Sequential(
ConvTranspose2d(
num_filters[1],
num_upsample_filters[1],
upsample_strides[1],
stride=upsample_strides[1]),
BatchNorm2d(num_upsample_filters[1]),
nn.ReLU(),
)
self.block3 = Sequential(
nn.ZeroPad2d(1),
Conv2d(num_filters[1], num_filters[2], 3, stride=layer_strides[2]),
BatchNorm2d(num_filters[2]),
nn.ReLU(),
)
for i in range(layer_nums[2]):
self.block3.add(
Conv2d(num_filters[2], num_filters[2], 3, padding=1))
self.block3.add(BatchNorm2d(num_filters[2]))
self.block3.add(nn.ReLU())
self.deconv3 = Sequential(
ConvTranspose2d(
num_filters[2],
num_upsample_filters[2],
upsample_strides[2],
stride=upsample_strides[2]),
BatchNorm2d(num_upsample_filters[2]),
nn.ReLU(),
)
if encode_background_as_zeros:
num_cls = num_anchor_per_loc * num_class
else:
num_cls = num_anchor_per_loc * (num_class + 1)
self.conv_cls = nn.Conv2d(sum(num_upsample_filters), num_cls, 1)
self.conv_box = nn.Conv2d(
sum(num_upsample_filters), num_anchor_per_loc * box_code_size, 1)
if use_direction_classifier:
self.conv_dir_cls = nn.Conv2d(
sum(num_upsample_filters),
num_anchor_per_loc * num_direction_bins, 1)
if self._use_rc_net:
self.conv_rc = nn.Conv2d(
sum(num_upsample_filters), num_anchor_per_loc * box_code_size,
1)
