def __init__(self, cin, cout, stride=1, conv_cfg=None, norm_cfg=None): super(conv_duc, self).__init__() self.branch0 = ConvModule(cin, cout, kernel_size=3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.pool = nn.AvgPool2d(kernel_size=stride, stride=stride) down_ch = cout * stride * stride self.branch1_1 = ConvModule(cin, cin, kernel_size=3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.branch1_2 = ConvModule(cin, down_ch, kernel_size=1, stride=1, padding=0, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.up = nn.PixelShuffle(upscale_factor=stride) self.branch1 = nn.Sequential( self.pool, self.branch1_1, self.branch1_2, self.up, )
def _init_branch_layers(self, planes, idx=0): wh_layers, hm_layers = [], [] inp = planes if self.bn_before_head: wh_layers.append(nn.BatchNorm2d(inp)) hm_layers.append(nn.BatchNorm2d(inp)) for i in range(self.wh_head_conv_num[idx]): wh_layers.append( ConvModule(inp, self.wh_head_channels[idx], 3, padding=1, conv_cfg=self.conv_cfg)) inp = self.wh_head_channels[idx] if self.head_conv_cfg: wh_layers.append( build_conv_layer(self.head_conv_cfg, self.wh_head_channels[idx], 4, kernel_size=3, padding=1)) else: wh_layers.append( nn.Conv2d(self.wh_head_channels[idx], 4, 3, padding=1)) inp = planes for i in range(self.hm_head_conv_num[idx]): hm_layers.append( ConvModule(inp, self.hm_head_channels[idx], 3, padding=1, conv_cfg=self.conv_cfg)) inp = self.hm_head_channels[idx] if self.head_conv_cfg: hm_layers.append( build_conv_layer(self.head_conv_cfg, self.hm_head_channels[idx], self.num_fg, kernel_size=3, padding=1)) else: hm_layers.append( nn.Conv2d(self.hm_head_channels[idx], self.num_fg, 3, padding=1)) wh_layers = nn.Sequential(*wh_layers) hm_layers = nn.Sequential(*hm_layers) return wh_layers, hm_layers
def __init__(self, in_channels, num_levels, refine_level=2, refine_type=None, conv_cfg=None, norm_cfg=None): super(BFP, self).__init__() assert refine_type in [None, 'conv', 'non_local'] self.in_channels = in_channels self.num_levels = num_levels self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.refine_level = refine_level self.refine_type = refine_type assert 0 <= self.refine_level < self.num_levels if self.refine_type == 'conv': self.refine = ConvModule(self.in_channels, self.in_channels, 3, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg) elif self.refine_type == 'non_local': self.refine = NonLocal2D(self.in_channels, reduction=1, use_scale=False, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)
def __init__(self, cin, cout, dilation=1, conv_cfg=None, norm_cfg=None): super(Pang_unit_stride, self).__init__() self.branch0 = ConvModule(cin, cout, kernel_size=3, stride=2, padding=dilation, dilation=dilation, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.branch1 = ConvModule(cin, cout, kernel_size=1, stride=1, padding=0, conv_cfg=conv_cfg, norm_cfg=norm_cfg)
def _build_head(self, out_channel, conv_num=1, head_conv_plane=None): head_convs = [] for i in range(conv_num): inp = self._planes[-1] if i == 0 else head_conv_plane head_convs.append(ConvModule(inp, head_conv_plane, 3, padding=1)) inp = self._planes[-1] if conv_num <= 0 else head_conv_plane head_convs.append(nn.Conv2d(inp, out_channel, 1)) return nn.Sequential(*head_convs)
def __init__(self, in_channels=(512, 2048), planes=256, ffm_out_channels=(256, 512), num_levels=8, norm_cfg=dict(type='BN')): super(MLFPN, self).__init__() assert len(in_channels) == len(ffm_out_channels) == 2 self.planes = planes self.num_levels = num_levels # construct base features self.reduce_s8 = ConvModule(in_channels[0], ffm_out_channels[0], 3, padding=1, norm_cfg=norm_cfg) self.reduce_s16 = ConvModule(in_channels[1], ffm_out_channels[1], 1, norm_cfg=norm_cfg) # share same params self.leach = nn.ModuleList([ ConvModule( sum(ffm_out_channels), self.planes // 2, 1, norm_cfg=norm_cfg) ] * self.num_levels) for i in range(self.num_levels): side_channel = 512 if i == 0 else self.planes setattr(self, 'unet{}'.format(i + 1), TUM(first_block=(i == 0), input_planes=self.planes // 2, is_smooth=self.smooth, scales=self.num_scales, side_channel=side_channel, norm_cfg=norm_cfg)) # side channel isn't fixed. # construct SFAM module if self.sfam: self.sfam_module = SEBlock(self.planes, self.num_levels, self.num_scales, compress_ratio=16)
def _init_branch_layers(self, planes, idx=-1): wh_layers, hm_layers = [], [] inp = planes for outp in self.wh_head_channels[idx]: wh_layers.append( ConvModule(inp, outp, 3, padding=1, conv_cfg=self.conv_cfg)) inp = outp wh_layers.append(nn.Conv2d(inp, 4, 3, padding=1)) inp = planes for outp in self.hm_head_channels[idx]: hm_layers.append( ConvModule(inp, outp, 3, padding=1, conv_cfg=self.conv_cfg)) inp = outp hm_layers.append(nn.Conv2d(inp, self.num_fg, 3, padding=1)) wh_layers = nn.Sequential(*wh_layers) hm_layers = nn.Sequential(*hm_layers) return wh_layers, hm_layers
def __init__(self, channels=256, with_conv=True, norm_cfg=None): super(MergingCell, self).__init__() self.with_conv = with_conv if self.with_conv: self.conv_out = ConvModule(channels, channels, 3, padding=1, norm_cfg=norm_cfg, order=('act', 'conv', 'norm'))
def __init__(self, inplanes=(64, 128, 256, 512), planes=(256, 128, 64), outplane=64, shortcut_kernel=3, conv_cfg=None, norm_cfg=None, norm_eval=False): super(CTFPN, self).__init__() self.norm_eval = norm_eval # repeat deconv 3 times, 32x to 4x. self.deconv_layers = nn.ModuleList() self.shortcut_layers = nn.ModuleList() self.output_layers = nn.ModuleList() self.deconv_layers.extend( [self._make_deconv_layer(inplanes[-1], 1, [planes[0]], [4], norm_cfg=norm_cfg), self._make_deconv_layer(planes[0], 1, [planes[1]], [4], norm_cfg=norm_cfg), self._make_deconv_layer(planes[1], 1, [planes[2]], [4], norm_cfg=norm_cfg)]) padding = (shortcut_kernel - 1) // 2 self.shortcut_layers.extend( [ConvModule(inplanes[2], planes[0], shortcut_kernel, padding=padding, conv_cfg=conv_cfg, activation=None), ConvModule(inplanes[1], planes[1], shortcut_kernel, padding=padding, conv_cfg=conv_cfg, activation=None), ConvModule(inplanes[0], planes[2], shortcut_kernel, padding=padding, conv_cfg=conv_cfg, activation=None)]) self.output_layers.extend( [ConvModule(planes[0], outplane, 1, conv_cfg=conv_cfg, activation=None), ConvModule(planes[1], outplane, 1, conv_cfg=conv_cfg, activation=None), ConvModule(planes[2], outplane, 1, conv_cfg=conv_cfg, activation=None)])
def __init__(self, feature_channels=256, num_convs=3, num_levels=5, conv_out_channels=256, conv_cfg=None, norm_cfg=None): super(NSemanticPyramidNeck, self).__init__() self.num_convs = num_convs self.num_levels = num_levels self.conv_out_channels = conv_out_channels self.feature_channels = feature_channels self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.fp16_enabled = False # self.lateral_convs = nn.ModuleList() self.combine_convs = nn.ModuleList() # self.proto_convs = nn.ModuleList() for i in range(num_levels): self.combine_convs.append( nn.Sequential( ConvModule(self.feature_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg), ConvModule(self.conv_out_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg), ConvModule(self.conv_out_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg)))
def __init__(self, in_channels, out_channels, num_outs=5, pooling_type='AVG', conv_cfg=None, norm_cfg=None, with_cp=False, stride=1): super(HRFPN, self).__init__() assert isinstance(in_channels, list) self.in_channels = in_channels self.out_channels = out_channels self.num_ins = len(in_channels) self.num_outs = num_outs self.with_cp = with_cp self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.reduction_conv = ConvModule(sum(in_channels), out_channels, kernel_size=1, conv_cfg=self.conv_cfg, activation=None) self.fpn_convs = nn.ModuleList() for i in range(self.num_outs): self.fpn_convs.append( ConvModule(out_channels, out_channels, kernel_size=3, padding=1, stride=stride, conv_cfg=self.conv_cfg, activation=None)) if pooling_type == 'MAX': self.pooling = F.max_pool2d else: self.pooling = F.avg_pool2d
def _make_conv_layer(self, num_output): conv_layers = [] for i in range(self.stacked_convs): in_chn = self.inplane if i == 0 else self.head_conv conv_layers.append( ConvModule(in_chn, self.head_conv, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) conv_layers.append(nn.Conv2d(self.head_conv, num_output, 1)) return nn.Sequential(*conv_layers)
def _make_conv_layer(self, out_channel, conv_num=1, head_conv_plane=None): head_convs = [] if not self.new_wh_generate: head_conv_plane = self.head_conv if not head_conv_plane else head_conv_plane for i in range(conv_num): inp = self.planes[-1] if i == 0 else head_conv_plane head_convs.append( ConvModule(inp, head_conv_plane, 3, padding=1)) else: for i in range(conv_num): inp = self.planes[-1] if i == 0 else self.head_conv head_convs.append(ConvModule(inp, self.head_conv, 3, padding=1)) if head_conv_plane: head_convs.append( ConvModule(self.head_conv, head_conv_plane, 3, padding=1)) else: head_conv_plane = self.head_conv inp = self.planes[-1] if conv_num <= 0 else head_conv_plane head_convs.append(nn.Conv2d(inp, out_channel, 1)) return nn.Sequential(*head_convs)
def _make_conv_layer(self, out_channel, conv_num, use_exp_conv=False): head_convs = [] for i in range(conv_num): inp = self.planes[-1] if i == 0 else self.head_conv head_convs.append(ConvModule(inp, self.head_conv, 3, padding=1)) inp = self.planes[-1] if conv_num <= 0 else self.head_conv head_convs.append(nn.Conv2d(inp, out_channel, 1)) if use_exp_conv: head_convs.append( build_conv_layer(dict(type='ExpConv'), out_channel, out_channel, neg_x=True)) return nn.Sequential(*head_convs)
def _add_conv_fc_branch(self, num_branch_convs, num_branch_fcs, in_channels, is_shared=False): """Add shared or separable branch convs -> avg pool (optional) -> fcs """ last_layer_dim = in_channels # add branch specific conv layers branch_convs = nn.ModuleList() if num_branch_convs > 0: for i in range(num_branch_convs): conv_in_channels = (last_layer_dim if i == 0 else self.conv_out_channels) branch_convs.append( ConvModule(conv_in_channels, self.conv_out_channels, 3, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) last_layer_dim = self.conv_out_channels # add branch specific fc layers branch_fcs = nn.ModuleList() if num_branch_fcs > 0: # for shared branch, only consider self.with_avg_pool # for separated branches, also consider self.num_shared_fcs if (is_shared or self.num_shared_fcs == 0) and not self.with_avg_pool: last_layer_dim *= self.roi_feat_area for i in range(num_branch_fcs): fc_in_channels = (last_layer_dim if i == 0 else self.fc_out_channels) branch_fcs.append( nn.Linear(fc_in_channels, self.fc_out_channels)) last_layer_dim = self.fc_out_channels return branch_convs, branch_fcs, last_layer_dim
def __init__(self, first_block=True, input_planes=128, is_smooth=True, side_channel=512, scales=6, norm_cfg=dict(type='BN')): super(TUM, self).__init__() self.is_smooth = is_smooth self.first_block = first_block planes = 2 * input_planes in1 = input_planes if first_block else input_planes + side_channel self.layers = nn.Sequential() self.latlayer = nn.Sequential() self.toplayer = nn.Sequential( ConvModule(planes, planes, 1, norm_cfg=norm_cfg)) # from shallow to deep self.layers.add_module( '{}'.format(len(self.layers)), ConvModule(in1, planes, 3, stride=2, padding=1, norm_cfg=norm_cfg)) for i in range(scales - 2): stride, padding = (2, 1) if i != scales - 3 else (1, 0) self.layers.add_module( '{}'.format(len(self.layers)), ConvModule(planes, planes, 3, stride=stride, padding=padding, norm_cfg=norm_cfg)) # from deep to shallow for i in range(scales - 2): self.latlayer.add_module( '{}'.format(len(self.latlayer)), ConvModule(planes, planes, 3, norm_cfg=norm_cfg)) self.latlayer.add_module('{}'.format(len(self.latlayer)), ConvModule(in1, planes, 3, norm_cfg=norm_cfg)) if self.is_smooth: smooth = [] for i in range(scales - 1): smooth.append(ConvModule(planes, planes, 1, norm_cfg=norm_cfg)) self.smooth = nn.Sequential(*smooth)
def build_head(self, out_channel, conv_num=1, head_conv_plane=None, use_sym_conv=False): head_convs = [] head_conv_plane = self.head_conv if not head_conv_plane else head_conv_plane for i in range(conv_num): inp = self.planes[-1] if i == 0 else head_conv_plane head_convs.append( ConvModule(inp, head_conv_plane, self.head_conv_size, conv_cfg=self.conv_cfg, padding=1)) inp = self.planes[-1] if conv_num <= 0 else head_conv_plane if use_sym_conv: assert out_channel == 4 head_convs.append(nn.Conv2d(inp, out_channel, 3, padding=1)) # head_convs.append(ConvModule(inp, out_channel, 3, conv_cfg=dict(type='WHSymConv'))) else: if self.hm_last_3x3: head_convs.append(nn.Conv2d(inp, out_channel, 3, padding=1)) elif self.hm_last_3x3_d2: head_convs.append( nn.Conv2d(inp, out_channel, 3, padding=2, dilation=2)) elif self.hm_last_5x5: head_convs.append(nn.Conv2d(inp, out_channel, 5, padding=2)) elif self.hm_last_7x7: head_convs.append(nn.Conv2d(inp, out_channel, 7, padding=3)) elif self.hm_last_se3x3: head_convs.append(nn.Conv2d(inp, out_channel, 3, padding=1)) if not self.no_wh_se or out_channel != 4: head_convs.append(SEBlock(out_channel, compress_ratio=4)) else: head_convs.append(nn.Conv2d(inp, out_channel, 1)) return nn.Sequential(*head_convs)
def __init__(self, level): super(ASFF, self).__init__() self.level = level self.dim = [256, 128, 64] self.inter_dim = self.dim[self.level] if level == 0: self.stride_level_1 = ConvModule(128, self.inter_dim, 3, padding=1, stride=2, norm_cfg=dict(type='BN')) self.stride_level_2 = ConvModule(64, self.inter_dim, 3, padding=1, stride=2, norm_cfg=dict(type='BN')) self.expand = ConvModule(self.inter_dim, 256, 3, padding=1, norm_cfg=dict(type='BN')) elif level == 1: self.compress_level_0 = ConvModule(256, self.inter_dim, 1, norm_cfg=dict(type='BN')) self.stride_level_2 = ConvModule(64, self.inter_dim, 3, padding=1, stride=2, norm_cfg=dict(type='BN')) self.expand = ConvModule(self.inter_dim, 128, 3, padding=1, norm_cfg=dict(type='BN')) elif level == 2: self.compress_level_0 = ConvModule(256, self.inter_dim, 1, norm_cfg=dict(type='BN')) self.compress_level_1 = ConvModule(128, self.inter_dim, 1, norm_cfg=dict(type='BN')) self.expand = ConvModule(self.inter_dim, 64, 3, padding=1, norm_cfg=dict(type='BN')) compress_c = 16 self.weight_level_0 = ConvModule(self.inter_dim, compress_c, 1, norm_cfg=dict(type='BN')) self.weight_level_1 = ConvModule(self.inter_dim, compress_c, 1, norm_cfg=dict(type='BN')) self.weight_level_2 = ConvModule(self.inter_dim, compress_c, 1, norm_cfg=dict(type='BN')) self.weight_levels = nn.Conv2d(compress_c * 3, 3, kernel_size=1, stride=1, padding=0)
def __init__(self, inplanes=(64, 128, 256, 512), planes=(256, 128, 64), down_ratio=4, head_conv=256, wh_conv=64, hm_head_conv_num=2, wh_head_conv_num=2, num_classes=81, shortcut_kernel=3, conv_cfg=None, head_conv_size=3, use_trident=False, use_dla=False, wh_sym=False, upsample_vanilla_conv=False, upsample_multiscale_conv=False, up_conv_cfg=None, norm_cfg=dict(type='BN'), shortcut_cfg=(1, 2, 3), wh_offset_base=16., wh_area_process='log', wh_agnostic=True, wh_gaussian=True, box_size_range=None, two_stage=False, alpha=0.54, beta=0.54, hm_weight=1., dcn_mean=False, iou_type='giou', use_simple_nms=True, aug_reg=False, hm_last_3x3=False, hm_last_3x3_d2=False, hm_last_se3x3=False, hm_last_5x5=False, hm_last_7x7=False, no_wh_se=False, wh_weight=5., max_objs=128): super(AnchorHead, self).__init__() assert len(planes) in [2, 3, 4] shortcut_num = min(len(inplanes) - 1, len(planes)) assert shortcut_num == len(shortcut_cfg) assert wh_area_process in [None, 'norm', 'log', 'sqrt'] self.planes = planes self.head_conv = head_conv self.num_classes = num_classes self.conv_cfg = conv_cfg self.head_conv_size = head_conv_size self.use_trident = use_trident self.use_dla = use_dla self.wh_sym = wh_sym self.upsample_vanilla_conv = upsample_vanilla_conv self.upsample_multiscale_conv = upsample_multiscale_conv self.up_conv_cfg = up_conv_cfg self.wh_offset_base = wh_offset_base self.wh_area_process = wh_area_process self.wh_agnostic = wh_agnostic self.wh_gaussian = wh_gaussian self.box_size_range = box_size_range self.two_stage = two_stage self.alpha = alpha self.beta = beta self.hm_weight = hm_weight self.dcn_mean = dcn_mean self.iou_loss = eval(iou_type + '_loss') self.use_simple_nms = use_simple_nms self.aug_reg = aug_reg self.hm_last_3x3 = hm_last_3x3 self.hm_last_3x3_d2 = hm_last_3x3_d2 self.hm_last_se3x3 = hm_last_se3x3 self.no_wh_se = no_wh_se self.hm_last_5x5 = hm_last_5x5 self.hm_last_7x7 = hm_last_7x7 self.wh_weight = wh_weight self.max_objs = max_objs self.fp16_enabled = False self.down_ratio = down_ratio self.num_fg = num_classes - 1 self.wh_planes = 4 if wh_agnostic else 4 * self.num_fg self.base_loc = None # repeat upsampling n times. 32x to 4x by default. self.deconv_layers = nn.ModuleList([ self.build_upsample(inplanes[-1], planes[0], norm_cfg=norm_cfg), self.build_upsample(planes[0], planes[1], norm_cfg=norm_cfg) ]) for i in range(2, len(planes)): self.deconv_layers.append( self.build_upsample(planes[i - 1], planes[i], norm_cfg=norm_cfg, no_upsample=(down_ratio == 8))) padding = (shortcut_kernel - 1) // 2 self.shortcut_layers = self.build_shortcut( inplanes[:-1][::-1][:shortcut_num], planes[:shortcut_num], shortcut_cfg, kernel_size=shortcut_kernel, padding=padding) # heads self.wh = self.build_head(self.wh_planes, wh_head_conv_num, head_conv_plane=wh_conv, use_sym_conv=wh_sym) self.hm = self.build_head(self.num_fg, hm_head_conv_num) if two_stage: assert wh_agnostic self.align = RoIAlign(7, spatial_scale=1 / 4., sample_num=2) self.wh2 = nn.Sequential( ConvModule(self.planes[-1], 32, 5, norm_cfg=norm_cfg), # 3x3 ConvModule(32, 32, 3, norm_cfg=norm_cfg), ConvModule(32, 32, 1), ConvModule(32, 4, 1, activation=None))
def __init__(self, depth, num_stages=4, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1), out_indices=(0, 1, 2, 3), style='pytorch', frozen_stages=-1, conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=True, with_att=False, without_ip=False, without_dconv=False, num_branch=4, dcn=None, stage_with_dcn=(False, False, False, False), gcb=None, stage_with_gcb=(False, False, False, False), gen_attention=None, stage_with_gen_attention=((), (), (), ()), with_cp=False, zero_init_residual=True): super(IPN_kite, self).__init__() if depth not in self.arch_settings: raise KeyError('invalid depth {} for resnet'.format(depth)) self.depth = depth self.without_ip = without_ip self.with_att = with_att self.without_dconv = without_dconv self.num_branch = num_branch self.num_stages = num_stages assert num_stages >= 1 and num_stages <= 4 self.strides = strides self.dilations = dilations assert len(strides) == len(dilations) == num_stages self.out_indices = out_indices assert max(out_indices) < num_stages self.style = style self.frozen_stages = frozen_stages self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.with_cp = with_cp self.norm_eval = norm_eval self.dcn = dcn self.stage_with_dcn = stage_with_dcn if dcn is not None: assert len(stage_with_dcn) == num_stages self.gen_attention = gen_attention self.gcb = gcb self.stage_with_gcb = stage_with_gcb if gcb is not None: assert len(stage_with_gcb) == num_stages self.zero_init_residual = zero_init_residual self.block, stage_blocks = self.arch_settings[depth] self.stage_blocks = stage_blocks[:num_stages] self.inplanes = 64 if with_att: #self.attention2048 = MultiHeadAttention(n_head=3,d_model=2048,d_v=2048,d_k=2048) self.attention1024 = MultiHeadAttention(n_head=3, d_model=1024, d_v=64, d_k=64) self.attention512 = MultiHeadAttention(n_head=3, d_model=512, d_v=64, d_k=64) self.attention256 = MultiHeadAttention(n_head=3, d_model=256, d_v=64, d_k=64) self.maxpooling = nn.MaxPool2d(kernel_size=6, stride=6, padding=0) self._make_stem_layer() self.channel_setting = [256, 512, 1024, 2048] self.dconvs = nn.ModuleList() for i in range(self.num_stages - 1): #for j in range(self.num_stages - i - 1): dconv = ConvModule(self.channel_setting[i], self.channel_setting[i], 3, stride=1, padding=2, dilation=2, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=None, inplace=False) self.dconvs.append(dconv) self.res_layers = [] for i, num_blocks in enumerate(self.stage_blocks): stride = strides[i] dilation = dilations[i] dcn = self.dcn if self.stage_with_dcn[i] else None gcb = self.gcb if self.stage_with_gcb[i] else None planes = 64 * 2**i res_layer = make_res_layer( self.block, self.inplanes, planes, num_blocks, stride=stride, dilation=dilation, style=self.style, with_cp=with_cp, conv_cfg=conv_cfg, norm_cfg=norm_cfg, dcn=dcn, gcb=gcb, gen_attention=gen_attention, gen_attention_blocks=stage_with_gen_attention[i]) self.inplanes = planes * self.block.expansion layer_name = 'layer{}'.format(i + 1) self.add_module(layer_name, res_layer) self.res_layers.append(layer_name) self._freeze_stages() self.feat_dim = self.block.expansion * 64 * 2**( len(self.stage_blocks) - 1)
def __init__(self, depth, num_stages=4, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1), out_indices=(0, 1, 2, 3), style='pytorch', frozen_stages=-1, out_channels=256, conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=True, dcn=None, stage_with_dcn=(False, False, False, False), gcb=None, stage_with_gcb=(False, False, False, False), gen_attention=None, stage_with_gen_attention=((), (), (), ()), with_cp=False, zero_init_residual=True): super(ResNet2stream, self).__init__() if depth not in self.arch_settings: raise KeyError('invalid depth {} for resnet'.format(depth)) self.depth = depth self.num_stages = num_stages assert num_stages >= 1 and num_stages <= 4 self.strides = strides self.dilations = dilations assert len(strides) == len(dilations) == num_stages self.out_indices = out_indices assert max(out_indices) < num_stages self.style = style self.frozen_stages = frozen_stages self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.with_cp = with_cp self.norm_eval = norm_eval self.dcn = dcn self.stage_with_dcn = stage_with_dcn if dcn is not None: assert len(stage_with_dcn) == num_stages self.gen_attention = gen_attention self.gcb = gcb self.stage_with_gcb = stage_with_gcb if gcb is not None: assert len(stage_with_gcb) == num_stages self.zero_init_residual = zero_init_residual self.block, stage_blocks = self.arch_settings[depth] self.stage_blocks = stage_blocks[:num_stages] self.inplanes = 64 self._make_stem_layer() self.res_layers = [] for i, num_blocks in enumerate(self.stage_blocks): stride = strides[i] dilation = dilations[i] dcn = self.dcn if self.stage_with_dcn[i] else None gcb = self.gcb if self.stage_with_gcb[i] else None planes = 64 * 2**i res_layer = make_res_layer( self.block, self.inplanes, planes, num_blocks, stride=stride, dilation=dilation, style=self.style, with_cp=with_cp, conv_cfg=conv_cfg, norm_cfg=norm_cfg, dcn=dcn, gcb=gcb, gen_attention=gen_attention, gen_attention_blocks=stage_with_gen_attention[i]) self.inplanes = planes * self.block.expansion layer_name = 'layer{}'.format(i + 1) self.add_module(layer_name, res_layer) self.res_layers.append(layer_name) self.lateral_convs = nn.ModuleList() self.fpn_convs = nn.ModuleList() in_channels = self.channel_setting[depth] for i in range(0, self.num_stages): l_conv = ConvModule(in_channels[i], out_channels, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=None, inplace=False) fpn_conv = ConvModule(out_channels, out_channels, 3, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=None, inplace=False) self.lateral_convs.append(l_conv) self.fpn_convs.append(fpn_conv) self._freeze_stages() self.feat_dim = self.block.expansion * 64 * 2**( len(self.stage_blocks) - 1)
def _init_branch_layers(self, planes, upsample_inplane, shortcut_inplanes): upsample_layers = nn.ModuleList([ UpsamplingLayers( upsample_inplane, planes[0], norm_cfg=self.norm_cfg), UpsamplingLayers( planes[0], planes[1], norm_cfg=self.norm_cfg), ]) shortcut_layers = nn.ModuleList() for (inp, outp, layer_num) in zip(shortcut_inplanes, planes, self.shortcut_cfg): assert layer_num > 0, "Shortcut connection must be included." shortcut_layers.append( ShortcutConnection(inp, outp, [3] * layer_num, self.shortcut_conv_cfg)) wh_layers, hm_layers = [], [] inp = planes[-1] for i in range(self.wh_head_conv_num): wh_layers.append( ConvModule( inp, self.wh_head_channels, 3, padding=1, conv_cfg=self.conv_cfg)) inp = self.wh_head_channels if self.head_conv_cfg: wh_layers.append( build_conv_layer( self.head_conv_cfg, self.wh_head_channels, 4, kernel_size=3, padding=1 ) ) else: wh_layers.append(nn.Conv2d(self.wh_head_channels, 4, 3, padding=1)) inp = planes[-1] for i in range(self.hm_head_conv_num): hm_layers.append( ConvModule( inp, self.hm_head_channels, 3, padding=1, conv_cfg=self.conv_cfg)) inp = self.hm_head_channels if self.head_conv_cfg: hm_layers.append( build_conv_layer( self.head_conv_cfg, self.hm_head_channels, self.num_fg, kernel_size=3, padding=1 ) ) elif self.depthwise_hm: hm_layers.append(DepthwiseHead(self.hm_head_channels, self.num_fg, 3, conv_relu=self.relu_before_depthwise, depth_kernel_sizes=self.depth_kernel_sizes, depth_group=self.depth_group, use_deform=self.depth_deform)) else: hm_layers.append(nn.Conv2d(self.hm_head_channels, self.num_fg, 3, padding=1)) wh_layers = nn.Sequential(*wh_layers) hm_layers = nn.Sequential(*hm_layers) return upsample_layers, shortcut_layers, wh_layers, hm_layers
def __init__( self, conv_cfg=None, norm_cfg=None, ): super(FatNetSimple, self).__init__() self.conv1 = ConvModule(3, 64, kernel_size=3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv2 = ConvModule(64, 64, kernel_size=3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv3 = conv_duc(64, 32, stride=2, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv4 = conv_duc(32, 32, stride=2, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv5 = conv_duc(32, 16, stride=4, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv6 = conv_duc(16, 16, stride=4, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv7 = conv_duc(16, 16, stride=4, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv8 = conv_duc(16, 16, stride=8, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv9 = conv_duc(16, 16, stride=8, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv10 = conv_duc(16, 16, stride=8, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv11 = conv_duc(16, 16, stride=16, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv12 = conv_duc(16, 16, stride=16, conv_cfg=conv_cfg, norm_cfg=norm_cfg) self.conv13 = conv_duc(16, 16, stride=16, conv_cfg=conv_cfg, norm_cfg=norm_cfg)
def __init__(self, depth, num_stages=4, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1), out_indices=(0, 1, 2, 3), style='pytorch', frozen_stages=-1, conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=True, dcn=None, stage_with_dcn=(False, False, False, False), gcb=None, stage_with_gcb=(False, False, False, False), gen_attention=None, stage_with_gen_attention=((), (), (), ()), with_cp=False, zero_init_residual=True): super(IPN_fusing, self).__init__() if depth not in self.arch_settings: raise KeyError('invalid depth {} for resnet'.format(depth)) self.depth = depth self.num_stages = num_stages assert num_stages >= 1 and num_stages <= 4 self.strides = strides self.dilations = dilations assert len(strides) == len(dilations) == num_stages self.out_indices = out_indices assert max(out_indices) < num_stages self.style = style self.frozen_stages = frozen_stages self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.with_cp = with_cp self.norm_eval = norm_eval self.dcn = dcn self.stage_with_dcn = stage_with_dcn if dcn is not None: assert len(stage_with_dcn) == num_stages self.gen_attention = gen_attention self.gcb = gcb self.stage_with_gcb = stage_with_gcb if gcb is not None: assert len(stage_with_gcb) == num_stages self.zero_init_residual = zero_init_residual self.block, stage_blocks = self.arch_settings[depth] self.stage_blocks = stage_blocks[:num_stages] self.inplanes = 64 self._make_stem_layer() self.channel_setting = [256,512,1024,2048] # make col layer self.collayers = [[] for _ in range(self.num_stages)] for ii in range(self.num_stages-1): length = ii +1 for jj in range(length): collayer = ConvModule( self.channel_setting[jj], self.channel_setting[jj], 3, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=None, inplace=False) layer_name = 'col_layer{}_{}'.format(ii,jj) self.add_module(layer_name, collayer) self.collayers[ii].append(layer_name) # make row layer self.rowlayers = [[] for _ in range(self.num_stages)] for ii in range(1,self.num_stages): length = ii + 1 for jj in range(1,length): rowlayer = ConvModule( self.channel_setting[jj-1], self.channel_setting[jj], 3, stride=2, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=None, inplace=False) layer_name = 'row_layer{}_{}'.format(ii, jj) self.add_module(layer_name, rowlayer) self.rowlayers[ii].append(layer_name) self.res_layers = [] for i, num_blocks in enumerate(self.stage_blocks): stride = strides[i] dilation = dilations[i] dcn = self.dcn if self.stage_with_dcn[i] else None gcb = self.gcb if self.stage_with_gcb[i] else None planes = 64 * 2**i res_layer = make_res_layer( self.block, self.inplanes, planes, num_blocks, stride=stride, dilation=dilation, style=self.style, with_cp=with_cp, conv_cfg=conv_cfg, norm_cfg=norm_cfg, dcn=dcn, gcb=gcb, gen_attention=gen_attention, gen_attention_blocks=stage_with_gen_attention[i]) self.inplanes = planes * self.block.expansion layer_name = 'layer{}'.format(i + 1) self.add_module(layer_name, res_layer) self.res_layers.append(layer_name) self._freeze_stages() self.feat_dim = self.block.expansion * 64 * 2**( len(self.stage_blocks) - 1)
def __init__(self, in_channels, out_channels, num_outs, start_level=0, end_level=-1, add_extra_convs=False, extra_convs_on_inputs=True, relu_before_extra_convs=False, no_norm_on_lateral=False, conv_cfg=None, norm_cfg=None, activation=None): super(FPN, self).__init__() assert isinstance(in_channels, list) self.in_channels = in_channels self.out_channels = out_channels self.num_ins = len(in_channels) self.num_outs = num_outs self.activation = activation self.relu_before_extra_convs = relu_before_extra_convs self.no_norm_on_lateral = no_norm_on_lateral self.fp16_enabled = False if end_level == -1: self.backbone_end_level = self.num_ins assert num_outs >= self.num_ins - start_level else: # if end_level < inputs, no extra level is allowed self.backbone_end_level = end_level assert end_level <= len(in_channels) assert num_outs == end_level - start_level self.start_level = start_level self.end_level = end_level self.add_extra_convs = add_extra_convs self.extra_convs_on_inputs = extra_convs_on_inputs self.lateral_convs = nn.ModuleList() self.fpn_convs = nn.ModuleList() for i in range(self.start_level, self.backbone_end_level): l_conv = ConvModule( in_channels[i], out_channels, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg if not self.no_norm_on_lateral else None, activation=self.activation, inplace=False) fpn_conv = ConvModule(out_channels, out_channels, 3, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=self.activation, inplace=False) self.lateral_convs.append(l_conv) self.fpn_convs.append(fpn_conv) # add extra conv layers (e.g., RetinaNet) extra_levels = num_outs - self.backbone_end_level + self.start_level if add_extra_convs and extra_levels >= 1: for i in range(extra_levels): if i == 0 and self.extra_convs_on_inputs: in_channels = self.in_channels[self.backbone_end_level - 1] else: in_channels = out_channels extra_fpn_conv = ConvModule(in_channels, out_channels, 3, stride=2, padding=1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, activation=self.activation, inplace=False) self.fpn_convs.append(extra_fpn_conv)
def __init__(self, num_convs=4, feature_channels=256, mask_channels=80, combine_level=2, num_levels=5, conv_out_channels=256, groups=True, conv_cfg=None, norm_cfg=None): super(SemanticProcessNeck, self).__init__() self.num_convs = num_convs self.mask_channels = mask_channels self.combine_level = combine_level self.num_levels = num_levels self.conv_out_channels = conv_out_channels self.feature_channels = feature_channels self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.fp16_enabled = False self.groups = groups if self.groups: self.lateral_conv = ConvModule(self.mask_channels, self.mask_channels, 3, stride=2, padding=1, groups=self.mask_channels, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg) else: self.lateral_conv = ConvModule(self.mask_channels, self.mask_channels, 3, stride=2, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg) # self.convs = nn.ModuleList() # for i in range(self.num_convs): # # in_channels = self.in_channels if i == 0 else conv_out_channels # if self.groups: # self.convs.append( # ConvModule( # conv_out_channels, # conv_out_channels, # 3, # padding=1, # groups=in_channels, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg)) # else: # self.convs.append( # ConvModule( # conv_out_channels, # conv_out_channels, # 3, # padding=1, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg)) # self.conv_embedding = ConvModule( # conv_out_channels, # conv_out_channels, # 1, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg) # self.conv_logits = nn.Conv2d(conv_out_channels, self.num_classes, 1) self.combine_conv = ConvModule(self.mask_channels + self.feature_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg)
def __init__(self, in_channels, out_channels, num_outs, stack_times, start_level=0, end_level=-1, add_extra_convs=False, norm_cfg=None): super(NASFPN, self).__init__() assert isinstance(in_channels, list) self.in_channels = in_channels self.out_channels = out_channels self.num_ins = len(in_channels) # num of input feature levels self.num_outs = num_outs # num of output feature levels self.stack_times = stack_times self.norm_cfg = norm_cfg if end_level == -1: self.backbone_end_level = self.num_ins assert num_outs >= self.num_ins - start_level else: # if end_level < inputs, no extra level is allowed self.backbone_end_level = end_level assert end_level <= len(in_channels) assert num_outs == end_level - start_level self.start_level = start_level self.end_level = end_level self.add_extra_convs = add_extra_convs # add lateral connections self.lateral_convs = nn.ModuleList() for i in range(self.start_level, self.backbone_end_level): l_conv = ConvModule(in_channels[i], out_channels, 1, norm_cfg=norm_cfg, activation=None) self.lateral_convs.append(l_conv) # add extra downsample layers (stride-2 pooling or conv) extra_levels = num_outs - self.backbone_end_level + self.start_level self.extra_downsamples = nn.ModuleList() for i in range(extra_levels): extra_conv = ConvModule(out_channels, out_channels, 1, norm_cfg=norm_cfg, activation=None) self.extra_downsamples.append( nn.Sequential(extra_conv, nn.MaxPool2d(2, 2))) # add NAS FPN connections self.fpn_stages = nn.ModuleList() for _ in range(self.stack_times): stage = nn.ModuleDict() # gp(p6, p4) -> p4_1 stage['gp_64_4'] = GPCell(out_channels, norm_cfg=norm_cfg) # sum(p4_1, p4) -> p4_2 stage['sum_44_4'] = SumCell(out_channels, norm_cfg=norm_cfg) # sum(p4_2, p3) -> p3_out stage['sum_43_3'] = SumCell(out_channels, norm_cfg=norm_cfg) # sum(p3_out, p4_2) -> p4_out stage['sum_34_4'] = SumCell(out_channels, norm_cfg=norm_cfg) # sum(p5, gp(p4_out, p3_out)) -> p5_out stage['gp_43_5'] = GPCell(with_conv=False) stage['sum_55_5'] = SumCell(out_channels, norm_cfg=norm_cfg) # sum(p7, gp(p5_out, p4_2)) -> p7_out stage['gp_54_7'] = GPCell(with_conv=False) stage['sum_77_7'] = SumCell(out_channels, norm_cfg=norm_cfg) # gp(p7_out, p5_out) -> p6_out stage['gp_75_6'] = GPCell(out_channels, norm_cfg=norm_cfg) self.fpn_stages.append(stage)
def __init__(self, inplanes=(64, 128, 256, 512), planes=(256, 128, 64), head_conv=256, hm_head_conv_num=1, wh_head_conv_num=1, deconv_with_bias=False, num_classes=81, use_reg_offset=True, use_smooth_l1=False, use_exp_wh=False, use_giou=False, use_shortcut=False, use_upsample_conv=False, use_trident=False, use_dla=False, shortcut_cfg=(1, 1, 1), shortcut_attention=(False, False, False), shortcut_kernel=3, use_rep_points=False, rep_points_kernel=3, conv_cfg=None, norm_cfg=dict(type='BN'), neg_shortcut=False, hm_init_value=-2.19, use_exp_hm=False, use_truncate_gaussia=False, use_tight_gauusia=False, gt_plus_dot5=False, shortcut_in_shortcut=False, giou_weight=1., wh_weight=0.1, off_weight=1., hm_weight=1.): super(AnchorHead, self).__init__() assert len(planes) in [2, 3, 4] and \ len(planes) == len(shortcut_cfg) == len(shortcut_attention) self.down_ratio = 32 // 2**len(planes) self.planes = planes self.head_conv = head_conv self.deconv_with_bias = deconv_with_bias self.num_classes = num_classes self.num_fg = num_classes - 1 self.use_reg_offset = use_reg_offset self.use_shortcut = use_shortcut self.use_rep_points = use_rep_points assert rep_points_kernel in [3, 5] self.rep_points_kernel = rep_points_kernel self.use_exp_wh = use_exp_wh self.use_exp_hm = use_exp_hm self.use_upsample_conv = use_upsample_conv self.use_trident = use_trident self.use_dla = use_dla self.conv_cfg = conv_cfg self.neg_shortcut = neg_shortcut self.hm_init_value = hm_init_value self.wh_weight = wh_weight self.off_weight = off_weight self.hm_weight = hm_weight # repeat deconv n times. 32x to 4x by default. self.deconv_layers = nn.ModuleList([ self._make_deconv_layer(inplanes[-1], 1, [planes[0]], [4], norm_cfg=norm_cfg), self._make_deconv_layer(planes[0], 1, [planes[1]], [4], norm_cfg=norm_cfg) ]) for i in range(2, len(planes)): self.deconv_layers.append( self._make_deconv_layer(planes[i - 1], 1, [planes[i]], [4], norm_cfg=norm_cfg)) padding = (shortcut_kernel - 1) // 2 self.shortcut_layers = self._make_shortcut( inplanes[:-1][::-1][:len(planes)], planes, shortcut_cfg, shortcut_attention, kernel_size=shortcut_kernel, padding=padding, shortcut_in_shortcut=shortcut_in_shortcut) # heads if use_rep_points: assert hm_head_conv_num == wh_head_conv_num share_head_conv = [ ConvModule(self.planes[-1], head_conv, 3, padding=1) ] for i in range(1, wh_head_conv_num): share_head_conv.append( ConvModule(head_conv, head_conv, 3, padding=1)) self.share_head_conv = nn.Sequential(*share_head_conv) padding = 1 if rep_points_kernel == 3 else 2 kernel_spatial = rep_points_kernel**2 self.wh = nn.Conv2d(head_conv, kernel_spatial * 3, rep_points_kernel, padding=padding) self.hm = ModulatedDeformConv(head_conv, self.num_fg, rep_points_kernel, padding=padding) else: self.wh = self._make_conv_layer(2, wh_head_conv_num) self.hm = self._make_conv_layer(self.num_fg, hm_head_conv_num, use_exp_conv=use_exp_hm) if use_reg_offset: self.reg = self._make_conv_layer(2, wh_head_conv_num) self._target_generator = CTTargetGenerator(self.num_fg, use_reg_offset, use_giou, use_truncate_gaussia, use_tight_gauusia, gt_plus_dot5, down_ratio=self.down_ratio) self._loss = CTLoss(use_reg_offset, use_smooth_l1, use_giou, giou_weight, wh_weight, off_weight, hm_weight)
def __init__(self, depth, num_stages=4, strides=(1, 2, 2, 2,2 ,2,1), dilations=(1, 1, 1, 1,1,1,2), out_indices=(0, 1, 2, 3,4,5,6), style='pytorch', frozen_stages=-1, conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=True, multiple=False, dcn=None, num_branch=4, stage_with_dcn=(False, False, False, False,False, False, False), gcb=None, stage_with_gcb=(False, False, False, False,False, False, False), gen_attention=None, stage_with_gen_attention=((), (), (), (),(), (), ()), with_cp=False, zero_init_residual=True): super(shareResNet_ju_conv, self).__init__() if depth not in self.arch_settings: raise KeyError('invalid depth {} for resnet'.format(depth)) self.depth = depth self.num_branch = num_branch self.num_stages = num_stages self.multiple = multiple assert num_stages >= 1 and num_stages <= 7 self.strides = strides self.dilations = dilations assert len(strides) == len(dilations) == num_stages self.out_indices = out_indices assert max(out_indices) < num_stages self.style = style self.frozen_stages = frozen_stages self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.with_cp = with_cp self.norm_eval = norm_eval self.dcn = dcn self.stage_with_dcn = stage_with_dcn if dcn is not None: assert len(stage_with_dcn) == num_stages self.gen_attention = gen_attention self.gcb = gcb self.stage_with_gcb = stage_with_gcb if gcb is not None: assert len(stage_with_gcb) == num_stages self.zero_init_residual = zero_init_residual self.block, stage_blocks = self.arch_settings[depth] self.stage_blocks = stage_blocks[:num_stages] self.inplanes = 64 self._make_stem_layer() self.res_layers = [] for i, num_blocks in enumerate(self.stage_blocks): stride = strides[i] dilation = dilations[i] dcn = self.dcn if self.stage_with_dcn[i] else None gcb = self.gcb if self.stage_with_gcb[i] else None planes = 64 * 2**i if i>=4: planes = 64 *2**3 res_layer = make_res_layer( self.block, self.inplanes, planes, num_blocks, stride=stride, dilation=dilation, style=self.style, with_cp=with_cp, conv_cfg=conv_cfg, norm_cfg=norm_cfg, dcn=dcn, gcb=gcb, gen_attention=gen_attention, gen_attention_blocks=stage_with_gen_attention[i]) self.inplanes = planes * self.block.expansion layer_name = 'layer{}'.format(i + 1) self.add_module(layer_name, res_layer) self.res_layers.append(layer_name) self._freeze_stages() self.feat_dim = self.block.expansion * 64 * 2**( len(self.stage_blocks) - 1) self.maxpool2048_256 = nn.MaxPool3d(kernel_size=(8,1,1),stride=(8,1,1),padding=(0,0,0)) self.maxpool1024_256 = nn.MaxPool3d(kernel_size=(4,1,1),stride=(4,1,1),padding=(0,0,0)) self.maxpool512_256 = nn.MaxPool3d(kernel_size=(2,1,1),stride=(2,1,1),padding=(0,0,0)) self.conv512_256 = ConvModule( 512, 256, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, inplace=False) self.conv1024_256 = ConvModule( 1024, 256, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, inplace=False) self.conv2048_256 = ConvModule( 2048, 256, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg, inplace=False)
def __init__(self, feature_channels=256, mask_channels=80, num_convs=3, ds_method='interpolate', num_levels=5, proto_out=8, conv_out_channels=256, groups=True, conv_cfg=None, norm_cfg=None): super(SemanticPyramidNeck, self).__init__() self.mask_channels = mask_channels self.num_convs = num_convs self.ds_method = ds_method self.num_levels = num_levels self.conv_out_channels = conv_out_channels self.feature_channels = feature_channels self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.proto_out = proto_out self.fp16_enabled = False self.groups = groups if self.ds_method == 'conv': self.ds_convs = nn.ModuleList() for i in range(self.num_levels - 1): self.ds_convs.append( ConvModule(self.mask_channels, self.mask_channels, 3, stride=2, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg)) # self.lateral_convs = nn.ModuleList() self.combine_convs = nn.ModuleList() # self.proto_convs = nn.ModuleList() for i in range(num_levels): # convs = nn.ModuleList() # feats_stride = 1 if i==0 else 2 # if self.groups: # self.lateral_convs.append(ConvModule(self.mask_channels,self.mask_channels, 3, stride=feats_stride, padding=1, # groups = self.mask_channels, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg)) # else: # self.lateral_convs.append(ConvModule( # self.mask_channels, self.mask_channels, 3, stride=feats_stride, padding=1, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg # )) # self.proto_convs.append(ConvModule(self.mask_channels, self.proto_out, 1, conv_cfg=conv_cfg, norm_cfg=norm_cfg)) # self.convs = nn.ModuleList() # for i in range(self.num_convs): # # in_channels = self.in_channels if i == 0 else conv_out_channels # if self.groups: # self.convs.append( # ConvModule( # conv_out_channels, # conv_out_channels, # 3, # padding=1, # groups=in_channels, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg)) # else: # self.convs.append( # ConvModule( # conv_out_channels, # conv_out_channels, # 3, # padding=1, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg)) # self.conv_embedding = ConvModule( # conv_out_channels, # conv_out_channels, # 1, # conv_cfg=self.conv_cfg, # norm_cfg=self.norm_cfg) # self.conv_logits = nn.Conv2d(conv_out_channels, self.num_classes, 1) # for j in range(self.num_convs): # in_channel = self.mask_channels + self.feature_channels if j==0 else self.feature_channels # convs.append(ConvModule(in_channel, self.conv_out_channels, 3, padding=1, # norm_cfg=norm_cfg, conv_cfg=conv_cfg)) # self.combine_convs.append(convs) if self.num_convs == 3: self.combine_convs.append( nn.Sequential( ConvModule(self.mask_channels + self.feature_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg), ConvModule(self.conv_out_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg), ConvModule(self.conv_out_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg))) elif self.num_convs == 2: self.combine_convs.append( nn.Sequential( ConvModule(self.mask_channels + self.feature_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg), ConvModule(self.conv_out_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg))) elif self.num_convs == 1: self.combine_convs.append( nn.Sequential( ConvModule(self.mask_channels + self.feature_channels, self.conv_out_channels, 3, padding=1, norm_cfg=norm_cfg, conv_cfg=conv_cfg)))