def init_weights(self):
normal_init(self.deform_conv, std=0.01)
def init_weights(self):
"""Initialize weights of classification layer."""
normal_init(self.conv_seg, mean=0, std=0.01)
def init_weights(self):
"""Initialize model weights."""
normal_init(self.conv, mean=0, std=0.001, bias=0)
def init_weights(self):
for m in self.ins_convs_x:
normal_init(m.conv, std=0.01)
for m in self.ins_convs_y:
normal_init(m.conv, std=0.01)
for m in self.cate_convs:
normal_init(m.conv, std=0.01)
bias_ins = bias_init_with_prob(0.01)
for m in self.dsolo_ins_list_x:
normal_init(m, std=0.01, bias=bias_ins)
for m in self.dsolo_ins_list_y:
normal_init(m, std=0.01, bias=bias_ins)
bias_cate = bias_init_with_prob(0.01)
normal_init(self.dsolo_cate, std=0.01, bias=bias_cate)
def init_weights(self):
normal_init(self.conv_cls, std=0.01)
normal_init(self.conv_reg, std=0.01)
def init_weights(self):
normal_init(self.conv_offset, std=0.1)
normal_init(self.conv_adaption, std=0.01)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.fcos_cls, std=0.01, bias=bias_cls)
normal_init(self.fcos_reg, std=0.01)
normal_init(self.fcos_centerness, std=0.01)
normal_init(self.sip_cof, std=0.01)
normal_init(self.sip_mask_lat, std=0.01)
normal_init(self.sip_mask_lat0, std=0.01)
self.feat_align.init_weights()
for m in self.track_convs:
normal_init(m.conv, std=0.01)
def init_weights(self): for m in self.feature_adaptation: normal_init(m.conv, std=0.01) normal_init(self.regression_conv, std=0.01)
def init_weights(self):
"""Initialize weights of the head."""
for m in self.convs_pred:
normal_init(m, std=0.01)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
normal_init(m, std=0.01)
def init_weights(self):
"""Initialize weights of the head."""
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.reppoints_cls_conv, std=0.01)
normal_init(self.reppoints_cls_out, std=0.01, bias=bias_cls)
normal_init(self.reppoints_pts_init_conv, std=0.01)
normal_init(self.reppoints_pts_init_out, std=0.01)
normal_init(self.reppoints_pts_refine_conv, std=0.01)
normal_init(self.reppoints_pts_refine_out, std=0.01)
def init_weights(self):
"""Initialize weights of the head."""
super(FSAFHead, self).init_weights()
# The positive bias in self.retina_reg conv is to prevent predicted \
# bbox with 0 area
normal_init(self.retina_reg, std=0.01, bias=0.25)
def init_weights(self):
"""Initialize weights of the head."""
super().init_weights()
normal_init(self.conv_centerness, std=0.01)
def init_weights(self):
for m in self.fam_reg_convs:
normal_init(m.conv, std=0.01)
for m in self.fam_cls_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.fam_reg, std=0.01)
normal_init(self.fam_cls, std=0.01, bias=bias_cls)
if self.align_conv_type == 'AlignConv':
self.align_conv.init_weights()
elif self.align_conv_type == 'Conv':
normal_init(self.align_conv, std=0.01)
else:
normal_init(self.align_conv_offset, std=0.1)
normal_init(self.align_conv, std=0.01)
normal_init(self.or_conv, std=0.01)
for m in self.odm_reg_convs:
normal_init(m.conv, std=0.01)
for m in self.odm_cls_convs:
normal_init(m.conv, std=0.01)
normal_init(self.odm_cls, std=0.01, bias=bias_cls)
normal_init(self.odm_reg, std=0.01)
def init_weights(self):
normal_init(self.rpn_conv, std=0.01)
super(GARPNHead, self).init_weights()
def init_weights(self):
"""Initialize the weights of head."""
bias_cls = bias_init_with_prob(0.01)
normal_init(self.conv_cls, std=0.01, bias=bias_cls)
normal_init(self.conv_reg, std=0.01)
def init_weights(self):
"""Initialize weights of the head."""
for m in self.f_1_convs:
normal_init(m.conv, std=0.01)
for m in self.f_2_convs:
normal_init(m.conv, std=0.01)
for m in self.f_r_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.f_1_retina, std=0.01, bias=bias_cls)
normal_init(self.f_2_retina, std=0.01, bias=bias_cls)
normal_init(self.f_mil_retina, std=0.01, bias=bias_cls)
normal_init(self.f_r_retina, std=0.01)
def _init_conv(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
normal_init(m, std=0.01)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
for m in self.emb_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.yolact_cls, std=0.01, bias=bias_cls)
normal_init(self.yolact_reg, std=0.01)
normal_init(self.yolact_emb, std=0.01)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
self.feature_adaption_cls.init_weights()
self.feature_adaption_reg.init_weights()
bias_cls = bias_init_with_prob(0.01)
normal_init(self.conv_loc, std=0.01, bias=bias_cls)
normal_init(self.conv_shape, std=0.01)
normal_init(self.retina_cls, std=0.01, bias=bias_cls)
normal_init(self.retina_reg, std=0.01)
def init_weights(self):
"""Initiate the parameters from scratch."""
normal_init(self.fc_cls, std=self.init_std)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
for m in self.offset_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.csp_cls, std=0.01, bias=bias_cls)
normal_init(self.csp_reg, std=0.01)
normal_init(self.csp_offset, std=0.01)
def init_weights(self):
normal_init(self.fc, mean=0, std=0.01, bias=0)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
for m in self.sac_convs:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.fcos_cls, std=0.01, bias=bias_cls)
normal_init(self.fcos_reg, std=0.01)
normal_init(self.fcos_saccade_score, std=0.01)
def init_weights(self):
normal_init(self.rpn_conv, std=0.01)
normal_init(self.rpn_cls, std=0.01)
normal_init(self.rpn_reg, std=0.01)
def init_weights(self):
for m in self.cls_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs:
normal_init(m.conv, std=0.01)
for m in self.reg_convs_3d:
normal_init(m.conv, std=0.01)
bias_cls = bias_init_with_prob(0.01)
normal_init(self.fcos_cls, std=0.01, bias=bias_cls)
normal_init(self.fcos_reg, std=0.01)
normal_init(self.fcos_reg_3d, std=0.01)
normal_init(self.fcos_centerness, std=0.01)
def init_weights(self):
"""Initialize weights of the head."""
normal_init(self.rpn_conv, std=0.01)
normal_init(self.rpn_cls, std=0.01)
normal_init(self.rpn_reg, std=0.01)
def init_weights(self, init_linear='normal'):
normal_init(self.predictor, std=0.01)
def _init_layers(self):
self.cls_convs = nn.ModuleList()
self.reg_convs = nn.ModuleList()
for i in range(self.stacked_convs - 1):
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))
for i in range(self.stacked_convs):
chn = self.in_channels if i == 0 else self.feat_channels
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.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
self.nc = 32
###########instance##############
self.feat_align = FeatureAlign(self.feat_channels,
self.feat_channels,
3,
flag_norm=self.norm_cfg is not None)
self.sip_cof = nn.Conv2d(self.feat_channels, self.nc * 4, 3, padding=1)
self.sip_mask_lat = nn.Conv2d(512, self.nc, 3, padding=1)
self.sip_mask_lat0 = nn.Conv2d(768, 512, 1, padding=0)
if self.rescoring_flag:
self.convs_scoring = []
channels = [1, 16, 16, 16, 32, 64, 128]
for i in range(6):
in_channels = channels[i]
out_channels = channels[i + 1]
stride = 2 if i == 0 else 2
padding = 0
self.convs_scoring.append(
ConvModule(in_channels,
out_channels,
3,
stride=stride,
padding=padding,
bias=True))
self.convs_scoring = nn.Sequential(*self.convs_scoring)
self.mask_scoring = nn.Conv2d(128, self.num_classes - 1, 1)
for m in self.convs_scoring:
kaiming_init(m.conv)
normal_init(self.mask_scoring, std=0.001)
self.relu = nn.ReLU(inplace=True)
self.crop_cuda = CropSplit(2)
self.crop_gt_cuda = CropSplitGt(2)
self.init_weights()
def init_weights(self):
"""Initialize last classification layer of MaskPointHead, conv layers are
already initialized by ConvModule"""
normal_init(self.fc_logits, std=0.001)
