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)