def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) assert self.num_anchors == 1, "anchor free version" self.gfl_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.gfl_reg = nn.Conv2d(self.feat_channels, 4 * (self.reg_max + 1), 3, padding=1) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.anchor_generator.strides])
def __init__(self, in_channels): super(CrissCrossAttention, self).__init__() self.query_conv = nn.Conv2d(in_channels, in_channels // 8, 1) self.key_conv = nn.Conv2d(in_channels, in_channels // 8, 1) self.value_conv = nn.Conv2d(in_channels, in_channels, 1) self.gamma = Scale(0.) self.in_channels = in_channels
def _init_layers(self): self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels if (self.dcn_on_last_conv and i == self.stacked_convs - 1): conv_cfg = dict(type='DCNv2') else: conv_cfg = self.conv_cfg self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=self.norm_cfg, bias=self.conv_bias)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=self.norm_cfg, bias=self.conv_bias)) self.fcos_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.fcos_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
def test_fcos_head_forward_single(): """Test fcos forward single in torch and ort env.""" fcos_model = fcos_config() feat = torch.rand(1, fcos_model.in_channels, 32, 32) fcos_model.forward_single = partial(fcos_model.forward_single, scale=Scale(1.0).requires_grad_(False), stride=(4, )) ort_validate(fcos_model.forward_single, feat)
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.mlvl_cls_convs = nn.ModuleList() self.mlvl_reg_convs = nn.ModuleList() self.mlvl_atss_cls_convs = nn.ModuleList() self.mlvl_atss_reg_convs = nn.ModuleList() self.mlvl_atss_centerness_convs = nn.ModuleList() for level in range(self.num_out): cls_convs = nn.ModuleList() reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) atss_cls = nn.Conv2d(self.feat_channels, self.num_anchors * self.cls_out_channels, 1, padding=0) atss_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 4, 1, padding=0) atss_centerness = nn.Conv2d(self.feat_channels, self.num_anchors * 1, 1, padding=0) self.mlvl_cls_convs.append(cls_convs) self.mlvl_reg_convs.append(reg_convs) self.mlvl_atss_cls_convs.append(atss_cls) self.mlvl_atss_reg_convs.append(atss_reg) self.mlvl_atss_centerness_convs.append(atss_centerness) if self.scale: self.scales = nn.ModuleList([ Scale(float(self.scale)) for _ in self.anchor_generator.strides ]) else: self.scales = nn.ModuleList( [nn.Identity() for _ in self.anchor_generator.strides])
def _init_layers(self): """Initialize layers of the head.""" super()._init_layers() self.conv_centerness_prev = self._init_branch( conv_channels=self.centerness_branch, conv_strides=(1, ) * len(self.centerness_branch)) self.conv_centerness = nn.Conv2d(self.centerness_branch[-1], 1, 1) self.scales = nn.ModuleList([ nn.ModuleList([Scale(1.0) for _ in range(3)]) for _ in self.strides ]) # only for offset, depth and size regression
def _init_layers(self): self.cls_convs = nn.ModuleList() self.wh_convs = nn.ModuleList() self.offset_convs = nn.ModuleList() self.rot_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.wh_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.offset_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.rot_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.center_hm = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1, bias=True) self.center_wh = nn.Conv2d(self.feat_channels, 2, 3, padding=1, bias=True) self.center_offset = nn.Conv2d(self.feat_channels, 2, 3, padding=1, bias=True) self.center_rot = nn.Conv2d(self.feat_channels, 1, 3, padding=1, bias=True) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
def _init_layers(self): """Initialize layers of the head.""" super()._init_layers() #self._init_reid_convs() self.conv_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) #self.conv_reid = nn.Conv2d(self.feat_channels, self.feat_channels, 3, padding=1) self.conv_reid = DeformConv2dPack(self.feat_channels, self.feat_channels, 3, 1, 1) #num_person = 359 num_person = 5532 #self.classifier_reid = nn.Linear(self.feat_channels, num_person) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.labeled_matching_layer = LabeledMatchingLayer(num_persons=num_person) # for mot17half self.unlabeled_matching_layer = UnlabeledMatchingLayer()
def _init_layers(self): """Initialize layers of the head.""" super(FCOSHead, self)._init_cls_convs() super(FCOSHead, self)._init_reg_convs() self.relu = nn.ReLU(inplace=True) self.vfnet_reg_conv = ConvModule(self.feat_channels, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.conv_bias) self.vfnet_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.vfnet_reg_refine = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.scales_refine = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.vfnet_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1)
def _init_layers(self): self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.fcos_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.fcos_reg = nn.Conv2d(self.feat_channels, 34, 3, padding=1) self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.scales_1 = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.scales_2 = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.feature_adaption = FeatureAdaption(256, 256, kernel_size=3, deform_groups=4) self.fcos_refine_out = nn.Conv2d(self.feat_channels, 34, 3, padding=1)
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.inter_convs = nn.ModuleList() for i in range(self.stacked_convs): if i < self.num_dcn: conv_cfg = dict(type='DCNv2', deform_groups=4) else: conv_cfg = self.conv_cfg chn = self.in_channels if i == 0 else self.feat_channels self.inter_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=self.norm_cfg)) self.cls_decomp = TaskDecomposition(self.feat_channels, self.stacked_convs, self.stacked_convs * 8, self.conv_cfg, self.norm_cfg) self.reg_decomp = TaskDecomposition(self.feat_channels, self.stacked_convs, self.stacked_convs * 8, self.conv_cfg, self.norm_cfg) self.tood_cls = nn.Conv2d(self.feat_channels, self.num_base_priors * self.cls_out_channels, 3, padding=1) self.tood_reg = nn.Conv2d(self.feat_channels, self.num_base_priors * 4, 3, padding=1) self.cls_prob_module = nn.Sequential( nn.Conv2d(self.feat_channels * self.stacked_convs, self.feat_channels // 4, 1), nn.ReLU(inplace=True), nn.Conv2d(self.feat_channels // 4, 1, 3, padding=1)) self.reg_offset_module = nn.Sequential( nn.Conv2d(self.feat_channels * self.stacked_convs, self.feat_channels // 4, 1), nn.ReLU(inplace=True), nn.Conv2d(self.feat_channels // 4, 4 * 2, 3, padding=1)) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.prior_generator.strides])
def _init_layers(self): """Initialize layers of the head.""" super()._init_layers() #self._init_reid_convs() self.conv_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) #self.conv_reid = nn.Conv2d(self.feat_channels, self.feat_channels, 3, padding=1) num_person = 483 # num_person = 5532 queue_size = 500 # queue_size = 5000 #self.classifier_reid = nn.Linear(self.feat_channels, num_person) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.labeled_matching_layer = LabeledMatchingLayerQueue( num_persons=num_person, feat_len=self.in_channels) # for mot17half self.unlabeled_matching_layer = UnlabeledMatchingLayer( queue_size=queue_size, feat_len=self.in_channels)
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=dict(type='DCN', deform_groups=1) if i == 0 and self.use_dcn else self.conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=dict(type='DCN', deform_groups=1) if i == 0 and self.use_dcn else self.conv_cfg, norm_cfg=self.norm_cfg)) self.atss_cls = nn.Conv2d(self.feat_channels, self.num_base_priors * self.cls_out_channels, 3, padding=1) self.atss_reg = nn.Conv2d(self.feat_channels, self.num_base_priors * 4, 3, padding=1) self.atss_iou = nn.Conv2d(self.feat_channels, self.num_base_priors * 1, 3, padding=1) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.prior_generator.strides]) # we use the global list in loss self.cls_num_pos_samples_per_level = [ 0. for _ in range(len(self.prior_generator.strides)) ] self.reg_num_pos_samples_per_level = [ 0. for _ in range(len(self.prior_generator.strides)) ]
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) conv_strides = [0] if self.strides_share else self.anchor_generator.strides self.cls_stride_convs = nn.ModuleDict() self.reg_stride_convs = nn.ModuleDict() self.stride_cls = nn.ModuleDict() self.stride_reg = nn.ModuleDict() if self.use_kps: self.stride_kps = nn.ModuleDict() for stride_idx, conv_stride in enumerate(conv_strides): #print('create convs for stride:', conv_stride) key = str(conv_stride) cls_convs = nn.ModuleList() reg_convs = nn.ModuleList() stacked_convs = self.stacked_convs[stride_idx] if isinstance(self.stacked_convs, (list, tuple)) else self.stacked_convs feat_mult = self.feat_mults[stride_idx] if self.feat_mults is not None else 1 feat_ch = int(self.feat_channels*feat_mult) for i in range(stacked_convs): chn = self.in_channels if i == 0 else last_feat_ch cls_convs.append( self._get_conv_module(chn, feat_ch) ) if not self.cls_reg_share: reg_convs.append( self._get_conv_module(chn, feat_ch) ) last_feat_ch = feat_ch self.cls_stride_convs[key] = cls_convs self.reg_stride_convs[key] = reg_convs self.stride_cls[key] = nn.Conv2d( feat_ch, self.cls_out_channels * self.num_anchors, 3, padding=1) if not self.use_dfl: self.stride_reg[key] = nn.Conv2d( feat_ch, 4 * self.num_anchors, 3, padding=1) else: self.stride_reg[key] = nn.Conv2d( feat_ch, 4 * (self.reg_max + 1) * self.num_anchors, 3, padding=1) if self.use_kps: self.stride_kps[key] = nn.Conv2d( feat_ch, self.NK*2*self.num_anchors, 3, padding=1) #assert self.num_anchors == 1, 'anchor free version' #extra_gflops /= 1e9 #print('extra_gflops: %.6fG'%extra_gflops) if self.use_scale: self.scales = nn.ModuleList( [Scale(1.0) for _ in self.anchor_generator.strides]) else: self.scales = [None for _ in self.anchor_generator.strides]
def _init_layers(self): self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for _ in self.anchor_generator.strides: cls_convs, reg_convs = self._build_not_shared_head() self.cls_convs.append(cls_convs) self.reg_convs.append(reg_convs) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.anchor_generator.strides]) self.gfl_cls = nn.ModuleList([nn.Conv2d(self.feat_channels, self.cls_out_channels + 4 * (self.reg_max + 1) if self.share_cls_reg else self.cls_out_channels, 1, padding=0) for _ in self.anchor_generator.strides]) self.gfl_reg = nn.ModuleList([nn.Conv2d(self.feat_channels, 4 * (self.reg_max + 1), 1, padding=0) for _ in self.anchor_generator.strides])
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) pred_pad_size = self.pred_kernel_size // 2 self.atss_cls = nn.Conv2d( self.feat_channels, self.num_anchors * self.cls_out_channels, self.pred_kernel_size, padding=pred_pad_size) self.atss_reg = nn.Conv2d( self.feat_channels, self.num_base_priors * 4, self.pred_kernel_size, padding=pred_pad_size) self.atss_centerness = nn.Conv2d( self.feat_channels, self.num_base_priors * 1, self.pred_kernel_size, padding=pred_pad_size) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.prior_generator.strides])
def __init__(self, in_channels, channels): super(PAM, self).__init__(key_in_channels=in_channels, query_in_channels=in_channels, channels=channels, out_channels=in_channels, share_key_query=False, query_downsample=None, key_downsample=None, key_query_num_convs=1, key_query_norm=False, value_out_num_convs=1, value_out_norm=False, matmul_norm=False, with_out=False, conv_cfg=None, norm_cfg=None, act_cfg=None) self.gamma = Scale(0)
def _init_layers(self): """Initialize layers of the head.""" dconv3x3_config = dict(type='DCNv2', kernel_size=3, use_bias=True, deformable_groups=2, padding=1) conv3x3_config = dict(type='Conv', kernel_size=3, padding=1) conv1x1_config = dict(type='Conv', kernel_size=1) self.arch_config = [ dconv3x3_config, conv3x3_config, dconv3x3_config, conv1x1_config ] self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i, op_ in enumerate(self.arch_config): op = copy.deepcopy(op_) chn = self.in_channels if i == 0 else self.feat_channels assert isinstance(op, dict) use_bias = op.pop('use_bias', False) padding = op.pop('padding', 0) kernel_size = op.pop('kernel_size') module = ConvModule(chn, self.feat_channels, kernel_size, stride=1, padding=padding, norm_cfg=self.norm_cfg, bias=use_bias, conv_cfg=op) self.cls_convs.append(copy.deepcopy(module)) self.reg_convs.append(copy.deepcopy(module)) self.fcos_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.fcos_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) assert self.num_anchors == 1, 'anchor free version' if self.one_more_cls_out_channels: self.cls_out_channels += 1 self.gfl_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.gfl_reg = nn.Conv2d(self.feat_channels, 4 * (self.reg_max + 1), 3, padding=1) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.prior_generator.strides]) if self.use_dgqp: conf_vector = [nn.Conv2d(4 * self.total_dim, self.reg_channels, 1)] conf_vector += [self.relu] conf_vector += [nn.Conv2d(self.reg_channels, 1, 1), nn.Sigmoid()] self.reg_conf = nn.Sequential(*conf_vector)
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels if self.dcn_on_last_conv and i == self.stacked_convs - 1: conv_cfg = dict(type='DCNv2') else: conv_cfg = self.conv_cfg self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=conv_cfg, norm_cfg=self.norm_cfg)) self.atss_cls = nn.Conv2d(self.feat_channels, self.num_anchors * self.cls_out_channels, 3, padding=1) self.atss_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 4, 3, padding=1) self.atss_centerness = nn.Conv2d(self.feat_channels, self.num_anchors * 1, 3, padding=1) self.scales = nn.ModuleList( [Scale(1.0) for _ in self.anchor_generator.strides])
def _init_layers(self): self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.fcos_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 3, padding=1) self.fcos_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.fcos_offset_conv = nn.Conv2d(self.feat_channels, self.feat_channels, 3, padding=1) self.fcos_offset = nn.Conv2d(self.feat_channels, 18, 1, 1, 0) self.fcos_cls_conv = DeformConv(self.feat_channels, self.feat_channels, 3, 1, 1) self.result = nn.Conv2d(4, 1, 3, padding=1) self.norm = nn.BatchNorm2d(1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
def _init_layers(self): self.relu = nn.ReLU(inplace=True) self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels self.cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) self.reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) self.atss_cls = nn.Conv2d(self.feat_channels, self.num_anchors * self.cls_out_channels, 3, padding=1) self.atss_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 5, 3, padding=1) self.atss_centerness = nn.Conv2d(self.feat_channels, self.num_anchors * 1, 3, padding=1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.anchor_strides])
def _init_layers(self): self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() for i in range(self.stacked_convs): # 4 * convs c = self.in_channels if i == 0 else self.feat_channels # d1: 88 # classification convolutional layers # waiting add.... self.cls_convs.append( ConvModule( c, # input channels self. feat_channels, # output channels KEEP SAME INPUT & OUTPUT SIZE 3, # 3 x 3 kernel size stride=1, padding=1, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.reg_convs.append( ConvModule(c, self.feat_channels, 3, stride=1, padding=1, normal_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.fcos_cls = nn.Conv2d(self.feat_channels, self.num_classes, 3, padding=1) self.fcos_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) # *l, *r, *t, *b self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) # criterion self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides ]) # [4, 8, 16, 32, 64]
def __init__(self, num_classes, in_channels, stacked_convs=4, conv_cfg=None, norm_cfg=None, anchor_generator=dict(type='AnchorGenerator', octave_base_scale=4, scales_per_octave=3, ratios=[0.5, 1.0, 2.0], strides=[8, 16, 32, 64, 128]), scalar_norm=False, **kwargs): self.stacked_convs = stacked_convs self.conv_cfg = conv_cfg self.norm_cfg = norm_cfg self.scalar_norm = scalar_norm super(ATSSRetinaHead, self).__init__(num_classes, in_channels, anchor_generator=anchor_generator, **kwargs) if self.scalar_norm: self.scales = nn.ModuleList( [Scale(1.0) for _ in self.anchor_generator.strides])
def _init_layers(self): """Initialize layers of the head.""" super()._init_layers() self.conv_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
def __init__(self): super(CAM, self).__init__() self.gamma = Scale(0)
def __init__(self, in_channels, out_channels, conv_cfg, num_stack=1): """ Args: num_channels: conv_channels: first_time: whether the input comes directly from the efficientnet, if True, downchannel it first, and downsample P5 to generate P6 then P7 epsilon: epsilon of fast weighted attention sum of BiFPN, not the BN's epsilon onnx_export: if True, use Swish instead of MemoryEfficientSwish """ super(YeFPN, self).__init__() assert isinstance(conv_cfg, dict), "conv_cfg should be dict!" conv_type = conv_cfg["type"] conv_info = conv_cfg["info"] assert isinstance(conv_type, str), "conv_type should be string!" # assert isinstance(conv_info, dict), "conv_info should be dict!" assert "norm_cfg" in conv_info norm_cfg = conv_info["norm_cfg"] Conv = build_op(conv_type) # Conv layers self.lateral_P3 = ConvModule(in_channels[0], out_channels, kernel_size=1, norm_cfg=norm_cfg) self.lateral_P4 = ConvModule(in_channels[1], out_channels, kernel_size=1, norm_cfg=norm_cfg) self.lateral_P5 = ConvModule(in_channels[2], out_channels, kernel_size=1, norm_cfg=norm_cfg) self.lateral_P6 = ConvModule(in_channels[3], out_channels, kernel_size=1, norm_cfg=norm_cfg) self.lateral_P7 = ConvModule(in_channels[4], out_channels, kernel_size=1, norm_cfg=norm_cfg) # self.conv7_1 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) # self.conv6_1 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) # self.conv5_1 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) # self.conv4_1 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) # self.conv3_1 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.conv7_2 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.conv6_2 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.conv5_2 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.conv4_2 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.conv3_2 = Conv(out_channels, out_channels, kernel_size=3, **conv_info) self.dowm_con6_7 = ConvModule(out_channels, out_channels, kernel_size=3, stride=2, padding=1, norm_cfg=norm_cfg) self.dowm_con5_6 = ConvModule(out_channels, out_channels, kernel_size=3, stride=2, padding=1, norm_cfg=norm_cfg) self.dowm_con4_5 = ConvModule(out_channels, out_channels, kernel_size=3, stride=2, padding=1, norm_cfg=norm_cfg) self.dowm_con3_4 = ConvModule(out_channels, out_channels, kernel_size=3, stride=2, padding=1, norm_cfg=norm_cfg) self.upsample7_6 = F.interpolate self.upsample6_5 = F.interpolate self.upsample5_4 = F.interpolate self.upsample4_3 = F.interpolate self.shortcut6_7 = F.interpolate self.shortcut4_3 = F.interpolate self.scale7_6 = Scale() self.scale6_5 = Scale() self.scale5_4 = Scale() self.scale4_3 = Scale() self.scale6_7 = Scale() self.scale5_6 = Scale() self.scale4_5 = Scale() self.scale3_4 = Scale()
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.topk_conv = nn.ModuleList() self.mlvl_cls = nn.ModuleList() self.mlvl_reg = nn.ModuleList() self.mlvl_gfl_cls = nn.ModuleList() self.mlvl_gfl_reg = nn.ModuleList() self.mlvl_conf_vector = nn.ModuleList() for level in range(self.num_out): cls_convs = nn.ModuleList() reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) gfl_cls = nn.Conv2d(self.feat_channels, self.num_anchors * self.cls_out_channels, 1, padding=0) gfl_reg = nn.Conv2d(self.feat_channels, 4 * (self.reg_max + 1), 1, padding=0) topk = topk_conv(self.reg_max, self.total_dim) conf_vector = [nn.Conv2d(4 * self.total_dim, self.reg_channels, 1)] conf_vector += [self.relu] conf_vector += [nn.Conv2d(self.reg_channels, 1, 1), nn.Sigmoid()] self.topk_conv.append(topk) self.mlvl_cls.append(cls_convs) self.mlvl_reg.append(reg_convs) self.mlvl_gfl_cls.append(gfl_cls) self.mlvl_gfl_reg.append(gfl_reg) self.mlvl_conf_vector.append(nn.Sequential(*conf_vector)) if self.scales: self.scales = nn.ModuleList([ Scale(float(self.scales)) for _ in self.anchor_generator.strides ]) else: self.scales = nn.ModuleList( [nn.Identity() for _ in self.anchor_generator.strides])
def _init_layers(self): self.cls_convs = nn.ModuleList() self.reg_convs = nn.ModuleList() self.mask_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels if not self.use_dcn: self.cls_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.reg_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) self.mask_convs.append( ConvModule( chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.norm_cfg is None)) else: self.cls_convs.append( ModulatedDeformConv2dPack( chn, self.feat_channels, 3, stride=1, padding=1, dilation=1, deformable_groups=1, )) if self.norm_cfg: self.cls_convs.append(build_norm_layer( self.norm_cfg, self.feat_channels)[1]) self.cls_convs.append(nn.ReLU(inplace=True)) self.reg_convs.append( ModulatedDeformConv2dPack( chn, self.feat_channels, 3, stride=1, padding=1, dilation=1, deformable_groups=1, )) if self.norm_cfg: self.reg_convs.append(build_norm_layer( self.norm_cfg, self.feat_channels)[1]) self.reg_convs.append(nn.ReLU(inplace=True)) self.mask_convs.append( ModulatedDeformConv2dPack( chn, self.feat_channels, 3, stride=1, padding=1, dilation=1, deformable_groups=1, )) if self.norm_cfg: self.mask_convs.append(build_norm_layer( self.norm_cfg, self.feat_channels)[1]) self.mask_convs.append(nn.ReLU(inplace=True)) self.polar_cls = nn.Conv2d( self.feat_channels, self.cls_out_channels, 3, padding=1) self.polar_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) self.polar_mask = nn.Conv2d(self.feat_channels, 36, 3, padding=1) self.polar_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) self.scales_bbox = nn.ModuleList([Scale(1.0) for _ in self.strides]) self.scales_mask = nn.ModuleList([Scale(1.0) for _ in self.strides])
def _init_layers(self): """Initialize layers of the head.""" self.relu = nn.ReLU(inplace=True) self.mlvl_cls_convs = nn.ModuleList() self.mlvl_reg_convs = nn.ModuleList() self.mlvl_vfl_cls_convs = nn.ModuleList() self.mlvl_vfl_reg_convs = nn.ModuleList() self.mlvl_vfl_reg = nn.ModuleList() self.mlvl_vfl_refine_convs = nn.ModuleList() self.mlvl_scale = nn.ModuleList() self.mlvl_refine_scale = nn.ModuleList() if self.reg_cls_branch: self.mlvl_vfl_reg_cls = nn.ModuleList() for level in range(self.num_out): cls_convs = nn.ModuleList() reg_convs = nn.ModuleList() for i in range(self.stacked_convs): chn = self.in_channels if i == 0 else self.feat_channels cls_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) reg_convs.append( ConvModule(chn, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg)) vfl_cls_convs = nn.Conv2d(self.feat_channels, self.cls_out_channels, 1, padding=0) vfl_reg_convs = ConvModule(self.feat_channels, self.feat_channels, 3, stride=1, padding=1, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, bias=self.conv_bias) vfl_refine_convs = nn.Conv2d(self.feat_channels, 4, 1, padding=0) vfl_reg = nn.Conv2d(self.feat_channels, 4, 1, padding=0) vfl_reg_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 1, padding=0) scale = Scale(1.0) scale_refine = Scale(1.0) self.mlvl_cls_convs.append(cls_convs) self.mlvl_reg_convs.append(reg_convs) self.mlvl_vfl_cls_convs.append(vfl_cls_convs) self.mlvl_vfl_reg_convs.append(vfl_reg_convs) self.mlvl_vfl_refine_convs.append(vfl_refine_convs) self.mlvl_vfl_reg.append(vfl_reg) if self.reg_cls_branch: self.mlvl_vfl_reg_cls.append(vfl_reg_cls) self.mlvl_scale.append(scale) self.mlvl_refine_scale.append(scale_refine)