def _make_layer(self, inplanes, planes, num_blocks, stride=1): block = Sequential( nn.ZeroPad2d(1), nn.Conv2d(inplanes, planes, 3, stride=stride, bias=False), build_norm_layer(self._norm_cfg, planes)[1], nn.ReLU(), ) for j in range(num_blocks): block.add(nn.Conv2d(planes, planes, 3, padding=1, bias=False)) block.add(build_norm_layer(self._norm_cfg, planes)[1], ) block.add(nn.ReLU()) return block, planes
def _make_layer(self, inplanes, planes, num_blocks, stride=1): # 128, 128, 5, 1 block = Sequential( nn.ZeroPad2d(1), # to keep size of input and output feature map the same=128 nn.Conv2d(inplanes, planes, 3, stride=stride, bias=False), build_norm_layer(self._norm_cfg, planes)[1], # nn.BatchNorm2d(planes, eps=1e-3, momentum=0.01), nn.ReLU(), ) for j in range(num_blocks): block.add(nn.Conv2d(planes, planes, 3, padding=1, bias=False)) block.add(build_norm_layer(self._norm_cfg, planes)[1],) # nn.BatchNorm2d(planes, eps=1e-3, momentum=0.01) block.add(nn.ReLU()) return block, planes
def __init__( self, in_channels, num_cls, heads, head_conv=64, final_kernel=1, bn=False, init_bias=-2.19, **kwargs, ): super(DCNSepHead, self).__init__(**kwargs) # feature adaptation with dcn # use separate features for classification / regression self.feature_adapt_cls = FeatureAdaption(in_channels, in_channels, kernel_size=3, deformable_groups=4) self.feature_adapt_reg = FeatureAdaption(in_channels, in_channels, kernel_size=3, deformable_groups=4) # heatmap prediction head self.cls_head = Sequential( nn.Conv2d(in_channels, head_conv, kernel_size=3, padding=1, bias=True), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(head_conv, num_cls, kernel_size=3, stride=1, padding=1, bias=True)) self.cls_head[-1].bias.data.fill_(init_bias) # other regression target self.task_head = SepHead(in_channels, heads, head_conv=head_conv, bn=bn, final_kernel=final_kernel)
def __init__(self, layer_nums, ds_layer_strides, ds_num_filters, us_layer_strides, us_num_filters, num_input_features, norm_cfg=None, name="rpn", logger=None, **kwargs): super(RPN, self).__init__() self._layer_strides = ds_layer_strides self._num_filters = ds_num_filters self._layer_nums = layer_nums self._upsample_strides = us_layer_strides self._num_upsample_filters = us_num_filters self._num_input_features = num_input_features if norm_cfg is None: norm_cfg = dict(type="BN", eps=1e-3, momentum=0.01) self._norm_cfg = norm_cfg assert len(self._layer_strides) == len(self._layer_nums) assert len(self._num_filters) == len(self._layer_nums) assert len(self._num_upsample_filters) == len(self._upsample_strides) self._upsample_start_idx = len(self._layer_nums) - len( self._upsample_strides) must_equal_list = [] for i in range(len(self._upsample_strides)): # print(upsample_strides[i]) must_equal_list.append(self._upsample_strides[i] / np.prod( self._layer_strides[:i + self._upsample_start_idx + 1])) for val in must_equal_list: assert val == must_equal_list[0] in_filters = [self._num_input_features, *self._num_filters[:-1]] blocks = [] deblocks = [] for i, layer_num in enumerate(self._layer_nums): block, num_out_filters = self._make_layer( in_filters[i], self._num_filters[i], layer_num, stride=self._layer_strides[i], ) blocks.append(block) if i - self._upsample_start_idx >= 0: stride = (self._upsample_strides[i - self._upsample_start_idx]) if stride > 1: deblock = Sequential( nn.ConvTranspose2d( num_out_filters, self._num_upsample_filters[ i - self._upsample_start_idx], stride, stride=stride, bias=False, ), build_norm_layer( self._norm_cfg, self._num_upsample_filters[ i - self._upsample_start_idx], )[1], nn.ReLU(), ) else: stride = np.round(1 / stride).astype(np.int64) deblock = Sequential( nn.Conv2d( num_out_filters, self._num_upsample_filters[ i - self._upsample_start_idx], stride, stride=stride, bias=False, ), build_norm_layer( self._norm_cfg, self._num_upsample_filters[ i - self._upsample_start_idx], )[1], nn.ReLU(), ) deblocks.append(deblock) self.blocks = nn.ModuleList(blocks) self.deblocks = nn.ModuleList(deblocks) logger.info("Finish RPN Initialization")
def __init__(self, layer_nums, ds_layer_strides, ds_num_filters, us_layer_strides, us_num_filters, num_input_features, norm_cfg=None, name="rpn", logger=None, **kwargs): super(FFSA, self).__init__() self._layer_strides = ds_layer_strides # [1,] self._num_filters = ds_num_filters # [128,] self._layer_nums = layer_nums # [5,] self._upsample_strides = us_layer_strides # [1,] self._num_upsample_filters = us_num_filters # [128,] self._num_input_features = num_input_features # 128 if norm_cfg is None: # True norm_cfg = dict(type="BN", eps=1e-3, momentum=0.01) self._norm_cfg = norm_cfg self.bottom_up_block_0 = Sequential( nn.ZeroPad2d(1), nn.Conv2d(128, 128, 3, stride=1, bias=False), build_norm_layer(self._norm_cfg, 128)[1], nn.ReLU(), nn.Conv2d( in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), nn.Conv2d( in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.bottom_up_block_1 = Sequential( # [200, 176] -> [100, 88] nn.Conv2d( in_channels=128, out_channels=256, kernel_size=3, stride=2, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 256, )[1], nn.ReLU(), nn.Conv2d( in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 256, )[1], nn.ReLU(), nn.Conv2d( in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 256, )[1], nn.ReLU(), ) self.trans_0 = Sequential( nn.Conv2d( in_channels=128, out_channels=128, kernel_size=1, stride=1, padding=0, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.trans_1 = Sequential( nn.Conv2d( in_channels=256, out_channels=256, kernel_size=1, stride=1, padding=0, bias=False, ), build_norm_layer( self._norm_cfg, 256, )[1], nn.ReLU(), ) self.deconv_block_0 = Sequential( nn.ConvTranspose2d( in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.deconv_block_1 = Sequential( nn.ConvTranspose2d( in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.conv_0 = Sequential( nn.Conv2d( in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.w_0 = Sequential( nn.Conv2d( in_channels=128, out_channels=1, kernel_size=1, stride=1, padding=0, bias=False, ), build_norm_layer( self._norm_cfg, 1, )[1], ) self.conv_1 = Sequential( nn.Conv2d( in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1, bias=False, ), build_norm_layer( self._norm_cfg, 128, )[1], nn.ReLU(), ) self.w_1 = Sequential( nn.Conv2d( in_channels=128, out_channels=1, kernel_size=1, stride=1, padding=0, bias=False, ), build_norm_layer( self._norm_cfg, 1, )[1], ) logger.info("Finish RPN Initialization")
def __init__( self, in_channels, heads, head_conv=64, final_kernel=1, bn=False, init_bias=-2.19, **kwargs, ): super(SepHead, self).__init__(**kwargs) self.heads = heads for head in self.heads: classes, num_conv = self.heads[head] fc = Sequential() for i in range(num_conv - 1): fc.add( nn.Conv2d(in_channels, head_conv, kernel_size=final_kernel, stride=1, padding=final_kernel // 2, bias=True)) if bn: fc.add(nn.BatchNorm2d(head_conv)) fc.add(nn.ReLU()) fc.add( nn.Conv2d(head_conv, classes, kernel_size=final_kernel, stride=1, padding=final_kernel // 2, bias=True)) if 'hm' in head: fc[-1].bias.data.fill_(init_bias) else: for m in fc.modules(): if isinstance(m, nn.Conv2d): kaiming_init(m) self.__setattr__(head, fc)
def __init__(self, layer_nums, ds_layer_strides, ds_num_filters, us_layer_strides, us_num_filters, num_input_features, norm_cfg=None, name="rpn", logger=None, **kwargs): super(RPN, self).__init__() self._layer_strides = ds_layer_strides # [1,] self._num_filters = ds_num_filters # [128,] self._layer_nums = layer_nums # [5,] self._upsample_strides = us_layer_strides # [1,] self._num_upsample_filters = us_num_filters # [128,] self._num_input_features = num_input_features # 128 if norm_cfg is None: # True norm_cfg = dict(type="BN", eps=1e-3, momentum=0.01) self._norm_cfg = norm_cfg assert len(self._layer_strides) == len(self._layer_nums) assert len(self._num_filters) == len(self._layer_nums) assert len(self._num_upsample_filters) == len(self._upsample_strides) self._upsample_start_idx = len(self._layer_nums) - len(self._upsample_strides) # 0 must_equal_list = [] for i in range(len(self._upsample_strides)): must_equal_list.append(self._upsample_strides[i] / np.prod(self._layer_strides[: i + self._upsample_start_idx + 1])) # [1] for val in must_equal_list: assert val == must_equal_list[0] in_filters = [self._num_input_features, *self._num_filters[:-1]] # [128] blocks = [] deblocks = [] for i, layer_num in enumerate(self._layer_nums): block, num_out_filters = self._make_layer(in_filters[i], self._num_filters[i], layer_num, stride=self._layer_strides[i],) # 128, 128, 5, 1 blocks.append(block) if i - self._upsample_start_idx >= 0: deblock = Sequential( nn.ConvTranspose2d( num_out_filters, # 128 self._num_upsample_filters[i - self._upsample_start_idx], # 128 self._upsample_strides[i - self._upsample_start_idx], # 1 stride=self._upsample_strides[i - self._upsample_start_idx], # 1 bias=False, ), # todo: attention here, add extra batch_norm implementation build_norm_layer(self._norm_cfg, self._num_upsample_filters[i - self._upsample_start_idx],)[1], # 128 nn.ReLU(), ) deblocks.append(deblock) self.blocks = nn.ModuleList(blocks) ''' 6 层二维卷积 self.blocks: (0): ZeroPad2d(padding=(1, 1, 1, 1), value=0.0) (1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), bias=False) (2): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (3): ReLU() (4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (5): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (6): ReLU() (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (8): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (9): ReLU() (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (11): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (12): ReLU() (13): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (14): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (15): ReLU() (16): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (17): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (18): ReLU() ''' self.deblocks = nn.ModuleList(deblocks) ''' 1层反卷积 self.deblocks: (0): Sequential( (0): ConvTranspose2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True) (2): ReLU() ) ''' logger.info("Finish RPN Initialization")
def __init__(self, layer_nums, ds_layer_strides, ds_num_filters, us_layer_strides, us_num_filters, num_input_features, norm_cfg=None, name="rpn", logger=None, **kwargs): super(RPN, self).__init__() self._layer_strides = ds_layer_strides # [1,] self._num_filters = ds_num_filters # [128,] self._layer_nums = layer_nums # [5,] self._upsample_strides = us_layer_strides # [1,] self._num_upsample_filters = us_num_filters # [128,] self._num_input_features = num_input_features # 128 if norm_cfg is None: # True norm_cfg = dict(type="BN", eps=1e-3, momentum=0.01) self._norm_cfg = norm_cfg assert len(self._layer_strides) == len(self._layer_nums) assert len(self._num_filters) == len(self._layer_nums) assert len(self._num_upsample_filters) == len(self._upsample_strides) self._upsample_start_idx = len(self._layer_nums) - len( self._upsample_strides) # 0 must_equal_list = [] for i in range(len(self._upsample_strides)): must_equal_list.append(self._upsample_strides[i] / np.prod( self._layer_strides[:i + self._upsample_start_idx + 1])) # [1] for val in must_equal_list: assert val == must_equal_list[0] in_filters = [self._num_input_features, *self._num_filters[:-1]] # [128] blocks = [] deblocks = [] for i, layer_num in enumerate(self._layer_nums): block, num_out_filters = self._make_layer( in_filters[i], self._num_filters[i], layer_num, stride=self._layer_strides[i], ) # 128, 128, 5, 1 blocks.append(block) if i - self._upsample_start_idx >= 0: deblock = Sequential( nn.ConvTranspose2d( num_out_filters, # 128 self._num_upsample_filters[ i - self._upsample_start_idx], # 128 self._upsample_strides[i - self._upsample_start_idx], # 1 stride=self._upsample_strides[ i - self._upsample_start_idx], # 1 bias=False, ), # todo: attention here, add extra batch_norm implementation build_norm_layer( self._norm_cfg, self._num_upsample_filters[i - self._upsample_start_idx], )[1], # 128 nn.ReLU(), ) deblocks.append(deblock) self.blocks = nn.ModuleList(blocks) self.deblocks = nn.ModuleList(deblocks) logger.info("Finish RPN Initialization")
def __init__(self, layer_nums, ds_layer_strides, ds_num_filters, us_layer_strides, us_num_filters, num_input_features, fpn_num_filters, norm_cfg=None, aggregation_method="concat", include_stem_layer=False, name="resnet_panoptic_fpn", logger=None, **kwargs): super(ResNet_Panoptic_FPN, self).__init__(layer_nums=layer_nums, ds_layer_strides=ds_layer_strides, ds_num_filters=ds_num_filters, num_input_features=num_input_features, fpn_num_filters=fpn_num_filters, include_stem_layer=include_stem_layer, norm_cfg=norm_cfg, logger=logger, **kwargs) self._upsample_strides = us_layer_strides self._num_upsample_filters = us_num_filters self._aggregation_method = aggregation_method assert len(self._num_upsample_filters) == len(self._upsample_strides) self._upsample_start_idx = len(self._layer_nums) - len( self._upsample_strides) must_equal_list = [] for i in range(len(self._upsample_strides)): # print(upsample_strides[i]) must_equal_list.append(self._upsample_strides[i] / np.prod( self._layer_strides[:i + self._upsample_start_idx + 1])) for val in must_equal_list: assert val == must_equal_list[0] deblocks = [] for i, layer_num in enumerate(self._layer_nums): num_out_filters = self._fpn_num_filters if i - self._upsample_start_idx >= 0: stride = (self._upsample_strides[i - self._upsample_start_idx]) if stride > 1: deblock = Sequential( nn.ConvTranspose2d( num_out_filters, self._num_upsample_filters[ i - self._upsample_start_idx], stride, stride=stride, bias=False, ), build_norm_layer( self._norm_cfg, self._num_upsample_filters[ i - self._upsample_start_idx], )[1], nn.ReLU(), ) else: stride = np.round(1 / stride).astype(np.int64) deblock = Sequential( nn.Conv2d( num_out_filters, self._num_upsample_filters[ i - self._upsample_start_idx], stride, stride=stride, bias=False, ), build_norm_layer( self._norm_cfg, self._num_upsample_filters[ i - self._upsample_start_idx], )[1], nn.ReLU(), ) deblocks.append(deblock) self.deblocks = nn.ModuleList(deblocks) logger.info("Finished initializing panoptic-fpn.")
def __init__(self, use_norm=True, num_class=2, layer_nums=[3, 3, 3, 3], layer_strides=[2, 2, 2, 2], num_filters=[64, 128, 256, 512], upsample_strides=[1, 2, 4, 4], num_upsample_filters=[64, 128, 256, 256, 448], num_input_filters=128, encode_background_as_zeros=True, use_groupnorm=False, num_groups=32, box_code_size=7, name='det_net'): super(det_net, self).__init__() assert len(layer_nums) == 4 assert len(layer_strides) == len(layer_nums) assert len(num_filters) == len(layer_nums) assert len(upsample_strides) == len(layer_nums) # print('use norm or not') # print(use_norm) 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) dimension_feature_map = num_filters #[ 64, 128, 256, 512] # [256, 512, 512, 512] dimension_concate = num_upsample_filters # last one for final output # =============================================================== # block0 # ============================================================== flag = 0 middle_layers = [] for i in range(layer_nums[flag]): middle_layers.append( Conv2d(dimension_feature_map[flag], dimension_feature_map[flag], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_feature_map[flag])) middle_layers.append(nn.ReLU()) self.block0 = Sequential(*middle_layers) middle_layers = [] self.downsample0 = Sequential( Conv2d(dimension_feature_map[flag], dimension_concate[flag], 3, stride=2), BatchNorm2d(dimension_concate[flag]), nn.ReLU(), ) # =============================================================== # block1 # ============================================================== flag = 1 middle_layers = [] for i in range(layer_nums[flag]): middle_layers.append( Conv2d(dimension_feature_map[flag], dimension_feature_map[flag], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_feature_map[flag])) middle_layers.append(nn.ReLU()) self.block1 = Sequential(*middle_layers) # =============================================================== # block2 # ============================================================== flag = 2 middle_layers = [] for i in range(layer_nums[flag]): middle_layers.append( Conv2d(dimension_feature_map[flag], dimension_feature_map[flag], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_feature_map[flag])) middle_layers.append(nn.ReLU()) self.block2 = Sequential(*middle_layers) # =============================================================== # block3 # ============================================================== flag = 3 middle_layers = [] for i in range(layer_nums[flag]): middle_layers.append( Conv2d(dimension_feature_map[flag], dimension_feature_map[flag], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_feature_map[flag])) middle_layers.append(nn.ReLU()) self.block3 = Sequential(*middle_layers) self.upsample3 = Sequential( ConvTranspose2d(dimension_feature_map[flag], dimension_concate[flag], 3, stride=2), BatchNorm2d(dimension_concate[flag]), nn.ReLU(), ) # ============================================================== # convlution after concatating block3 and block2 # ============================================================== middle_layers = [] middle_layers.append( Conv2d((dimension_concate[3] + dimension_feature_map[2]), dimension_concate[2], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_concate[2])) middle_layers.append(nn.ReLU()) middle_layers.append( Conv2d(dimension_concate[2], dimension_concate[2], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_concate[2])) middle_layers.append(nn.ReLU()) # upsampling middle_layers.append( ConvTranspose2d(dimension_concate[2], dimension_concate[2], 3, stride=2)) middle_layers.append(BatchNorm2d(dimension_concate[2])) middle_layers.append(nn.ReLU()) self.upsample2_after_concate_fuse32 = Sequential(*middle_layers) # ============================================================== # convlution after concatating block2, block1 and block0 # ============================================================== middle_layers = [] middle_layers.append( Conv2d((dimension_concate[0] + dimension_feature_map[1] + dimension_concate[2]), dimension_concate[4], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_concate[4])) middle_layers.append(nn.ReLU()) middle_layers.append( Conv2d(dimension_concate[4], dimension_concate[4], 3, padding=1)) middle_layers.append(BatchNorm2d(dimension_concate[4])) middle_layers.append(nn.ReLU()) self.output_after_concate_fuse210 = Sequential(*middle_layers)