[Enhance] Modify the Fcos3d init_weights methods (#705)

* support 3dssd

* support one-stage method

* for lint

* support two_stage

* Support all methods

* remove init_cfg=[] in configs

* test

* support h3dnet

* fix lint error

* fix isort

* fix code style error

* fix imvotenet bug

* rename init_weight->init_weights

* clean comma

* fix test_apis does not init weights

* support newest mmdet and mmcv

* fix test_heads h3dnet bug

* rm *.swp

* remove the wrong code in build.yml

* fix ssn low map

* modify docs

* modified ssn init_config

* modify params in backbone pointnet2_sa_ssg

* add ssn direction init_cfg

* support segmentor

* add conv a=sqrt(5)

* Convmodule uses kaiming_init

* fix centerpointhead init bug

* add second conv2d init cfg

* add unittest to confirm the input is not be modified

* assert gt_bboxes_3d

* rm .swag

* modify docs mmdet version

* adopt fcosmono3d

* add fcos 3d original init method

* add init cfg

* add init cfg

* modify fcos3d init_weights

* deleted error merge code

* deleted useless code

* remove useless code

mmdet3d/models/dense_heads/anchor_free_mono3d_head.py

@@ -161,6 +161,13 @@ class AnchorFreeMono3DHead(BaseMono3DDenseHead):
             self.attr_branch = attr_branch
 
         self._init_layers()
+        if init_cfg is None:
+            self.init_cfg = dict(
+                type='Normal',
+                layer='Conv2d',
+                std=0.01,
+                override=dict(
+                    type='Normal', name='conv_cls', std=0.01, bias_prob=0.01))
 
     def _init_layers(self):
         """Initialize layers of the head."""
@@ -266,29 +273,8 @@ class AnchorFreeMono3DHead(BaseMono3DDenseHead):
             self.conv_attr = nn.Conv2d(self.attr_branch[-1], self.num_attrs, 1)
 
     def init_weights(self):
-        """Initialize weights of the head."""
-        for modules in [self.cls_convs, self.reg_convs, self.conv_cls_prev]:
-            for m in modules:
-                if isinstance(m.conv, nn.Conv2d):
-                    normal_init(m.conv, std=0.01)
-        for conv_reg_prev in self.conv_reg_prevs:
-            if conv_reg_prev is None:
-                continue
-            for m in conv_reg_prev:
-                if isinstance(m.conv, nn.Conv2d):
-                    normal_init(m.conv, std=0.01)
-        if self.use_direction_classifier:
-            for m in self.conv_dir_cls_prev:
-                if isinstance(m.conv, nn.Conv2d):
-                    normal_init(m.conv, std=0.01)
-        if self.pred_attrs:
-            for m in self.conv_attr_prev:
-                if isinstance(m.conv, nn.Conv2d):
-                    normal_init(m.conv, std=0.01)
+        super().init_weights()
         bias_cls = bias_init_with_prob(0.01)
-        normal_init(self.conv_cls, std=0.01, bias=bias_cls)
-        for conv_reg in self.conv_regs:
-            normal_init(conv_reg, std=0.01)
         if self.use_direction_classifier:
             normal_init(self.conv_dir_cls, std=0.01, bias=bias_cls)
         if self.pred_attrs:

mmdet3d/models/dense_heads/fcos_mono3d_head.py

 import numpy as np
 import torch
-from mmcv.cnn import Scale, normal_init
+from mmcv.cnn import Scale
 from mmcv.runner import force_fp32
 from torch import nn as nn
 
@@ -94,6 +94,13 @@ class FCOSMono3DHead(AnchorFreeMono3DHead):
             init_cfg=init_cfg,
             **kwargs)
         self.loss_centerness = build_loss(loss_centerness)
+        if init_cfg is None:
+            self.init_cfg = dict(
+                type='Normal',
+                layer='Conv2d',
+                std=0.01,
+                override=dict(
+                    type='Normal', name='conv_cls', std=0.01, bias_prob=0.01))
 
     def _init_layers(self):
         """Initialize layers of the head."""
@@ -106,14 +113,6 @@ class FCOSMono3DHead(AnchorFreeMono3DHead):
             nn.ModuleList([Scale(1.0) for _ in range(3)]) for _ in self.strides
         ])  # only for offset, depth and size regression
 
-    def init_weights(self):
-        """Initialize weights of the head."""
-        super().init_weights()
-        for m in self.conv_centerness_prev:
-            if isinstance(m.conv, nn.Conv2d):
-                normal_init(m.conv, std=0.01)
-        normal_init(self.conv_centerness, std=0.01)
-
     def forward(self, feats):
         """Forward features from the upstream network.