text: import torch.nn as nn
  from mmcv.cnn import ConvModule
  
  from mmdet.models.builder import HEADS
  from .bbox_head import BBoxHead, BBoxParallelHead
  
  
  @HEADS.register_module()
  class ConvFCBBoxHead(BBoxHead):
      r"""More general bbox head, with shared conv and fc layers and two optional
      separated branches.
  
      .. code-block:: none
  
                                      /-> cls convs -> cls fcs -> cls
          shared convs -> shared fcs
                                      \-> reg convs -> reg fcs -> reg
      """  # noqa: W605
  
      def __init__(self,
                   num_shared_convs=0,
                   num_shared_fcs=0,
                   num_cls_convs=0,
                   num_cls_fcs=0,
                   num_reg_convs=0,
                   num_reg_fcs=0,
                   conv_out_channels=256,
                   fc_out_channels=1024,
                   conv_cfg=None,
                   norm_cfg=None,
                   *args,
                   **kwargs):
          super(ConvFCBBoxHead, self).__init__(*args, **kwargs)
          assert (num_shared_convs + num_shared_fcs + num_cls_convs +
                  num_cls_fcs + num_reg_convs + num_reg_fcs > 0)
          if num_cls_convs > 0 or num_reg_convs > 0:
              assert num_shared_fcs == 0
          if not self.with_cls:
              assert num_cls_convs == 0 and num_cls_fcs == 0
          if not self.with_reg:
              assert num_reg_convs == 0 and num_reg_fcs == 0
          self.num_shared_convs = num_shared_convs
          self.num_shared_fcs = num_shared_fcs
          self.num_cls_convs = num_cls_convs
          self.num_cls_fcs = num_cls_fcs
          self.num_reg_convs = num_reg_convs
          self.num_reg_fcs = num_reg_fcs
          self.conv_out_channels = conv_out_channels
          self.fc_out_channels = fc_out_channels
          self.conv_cfg = conv_cfg
          self.norm_cfg = norm_cfg
  
          # add shared convs and fcs
          self.shared_convs, self.shared_fcs, last_layer_dim = \
              self._add_conv_fc_branch(
                  self.num_shared_convs, self.num_shared_fcs, self.in_channels,
                  True)
          self.shared_out_channels = last_layer_dim
  
          # add cls specific branch
          self.cls_convs, self.cls_fcs, self.cls_last_dim = \
              self._add_conv_fc_branch(
                  self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels)
  
          # add reg specific branch
          self.reg_convs, self.reg_fcs, self.reg_last_dim = \
              self._add_conv_fc_branch(
                  self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels)
  
          if self.num_shared_fcs == 0 and not self.with_avg_pool:
              if self.num_cls_fcs == 0:
                  self.cls_last_dim *= self.roi_feat_area
              if self.num_reg_fcs == 0:
                  self.reg_last_dim *= self.roi_feat_area
  
          self.relu = nn.ReLU(inplace=True)
          # reconstruct fc_cls and fc_reg since input channels are changed
          if self.with_cls:
              self.fc_cls = nn.Linear(self.cls_last_dim, self.num_classes + 1)
          if self.with_reg:
              out_dim_reg = (4 if self.reg_class_agnostic else 4 *
                             self.num_classes)
              self.fc_reg = nn.Linear(self.reg_last_dim, out_dim_reg)
  
      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_weights(self):
          super(ConvFCBBoxHead, self).init_weights()
          # conv layers are already initialized by ConvModule
          for module_list in [self.shared_fcs, self.cls_fcs, self.reg_fcs]:
              for m in module_list.modules():
                  if isinstance(m, nn.Linear):
                      nn.init.xavier_uniform_(m.weight)
                      nn.init.constant_(m.bias, 0)
  
      def forward(self, x):
          # shared part
          if self.num_shared_convs > 0:
              for conv in self.shared_convs:
                  x = conv(x)
  
          if self.num_shared_fcs > 0:
              if self.with_avg_pool:
                  x = self.avg_pool(x)
  
              x = x.flatten(1)
  
              for fc in self.shared_fcs:
                  x = self.relu(fc(x))
          # separate branches
          x_cls = x
          x_reg = x
  
          for conv in self.cls_convs:
              x_cls = conv(x_cls)
          if x_cls.dim() > 2:
              if self.with_avg_pool:
                  x_cls = self.avg_pool(x_cls)
              x_cls = x_cls.flatten(1)
          for fc in self.cls_fcs:
              x_cls = self.relu(fc(x_cls))
  
          for conv in self.reg_convs:
              x_reg = conv(x_reg)
          if x_reg.dim() > 2:
              if self.with_avg_pool:
                  x_reg = self.avg_pool(x_reg)
              x_reg = x_reg.flatten(1)
          for fc in self.reg_fcs:
              x_reg = self.relu(fc(x_reg))
  
  
          cls_score = self.fc_cls(x_cls) if self.with_cls else None
          bbox_pred = self.fc_reg(x_reg) if self.with_reg else None
          return cls_score, bbox_pred
  
  @HEADS.register_module()
  class ConvOneParallelBBoxHead(BBoxParallelHead):
      r"""More general bbox head, with shared conv and fc layers and two optional
      separated branches.
  
      .. code-block:: none
  
                                      /-> cls convs -> cls fcs -> cls
          shared convs -> shared fcs
                                      \-> reg convs -> reg fcs -> reg
      """  # noqa: W605
  
      def __init__(self,
                   num_shared_convs=0,
                   num_shared_fcs=0,
                   num_cls_convs=0,
                   num_cls_fcs=0,
                   # 自己加的代码
                   num_iou_convs=0,
                   num_iou_fcs=0,
                   num_reg_convs=0,
                   num_reg_fcs=0,
                   conv_out_channels=256,
                   fc_out_channels=1024,
                   conv_cfg=None,
                   norm_cfg=None,
                   *args,
                   **kwargs):
          super(ConvOneParallelBBoxHead, self).__init__(*args, **kwargs)
          assert (num_shared_convs + num_shared_fcs + num_cls_convs +
                  num_cls_fcs + num_reg_convs + num_reg_fcs > 0)
          if num_cls_convs > 0 or num_reg_convs > 0:
              assert num_shared_fcs == 0
          if not self.with_cls:
              assert num_cls_convs == 0 and num_cls_fcs == 0
          if not self.with_reg:
              assert num_reg_convs == 0 and num_reg_fcs == 0
          self.num_shared_convs = num_shared_convs
          self.num_shared_fcs = num_shared_fcs
          self.num_cls_convs = num_cls_convs
          self.num_cls_fcs = num_cls_fcs
          self.num_iou_convs = num_iou_convs
          self.num_iou_fcs = num_iou_fcs
          self.num_reg_convs = num_reg_convs
          self.num_reg_fcs = num_reg_fcs
          self.conv_out_channels = conv_out_channels
          self.fc_out_channels = fc_out_channels
          self.conv_cfg = conv_cfg
          self.norm_cfg = norm_cfg
  
          # add shared convs and fcs
          self.shared_convs, self.shared_fcs, last_layer_dim = \
              self._add_conv_fc_branch(
                  self.num_shared_convs, self.num_shared_fcs, self.in_channels,
                  True)
          self.shared_out_channels = last_layer_dim
  
          # add cls specific branch
          self.cls_convs, self.cls_fcs, self.cls_last_dim = \
              self._add_conv_fc_branch(
                  self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels)
  
          # add iou specific branch
          self.iou_convs, self.iou_fcs, self.iou_last_dim = \
              self._add_conv_fc_branch(
                  self.num_iou_convs, self.num_iou_fcs, self.shared_out_channels)
  
          # add reg specific branch
          self.reg_convs, self.reg_fcs, self.reg_last_dim = \
              self._add_conv_fc_branch(
                  self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels)
  
          if self.num_shared_fcs == 0 and not self.with_avg_pool:
              if self.num_cls_fcs == 0:
                  self.cls_last_dim *= self.roi_feat_area
              if self.num_iou_fcs == 0:
                  self.iou_last_dim *= self.roi_feat_area
              if self.num_reg_fcs == 0:
                  self.reg_last_dim *= self.roi_feat_area
  
          self.relu = nn.ReLU(inplace=True)
          # reconstruct fc_cls and fc_reg since input channels are changed
          if self.with_cls:
              self.fc_cls = nn.Linear(self.cls_last_dim, self.num_classes + 1)
          if self.with_iou:
              self.fc_iou = nn.Linear(self.iou_last_dim, 1)
          if self.with_reg:
              out_dim_reg = (4 if self.reg_class_agnostic else 4 *
                             self.num_classes)
              self.fc_reg = nn.Linear(self.reg_last_dim, out_dim_reg)
  
      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_weights(self):
          super(ConvOneParallelBBoxHead, self).init_weights()
          # conv layers are already initialized by ConvModule
          for module_list in [self.shared_fcs, self.cls_fcs, self.iou_fcs, self.reg_fcs]:
              for m in module_list.modules():
                  if isinstance(m, nn.Linear):
                      nn.init.xavier_uniform_(m.weight)
                      nn.init.constant_(m.bias, 0)
  
      def forward(self, x):
          # shared part
          if self.num_shared_convs > 0:
              for conv in self.shared_convs:
                  x = conv(x)
  
          if self.num_shared_fcs > 0:
              if self.with_avg_pool:
                  x = self.avg_pool(x)
  
              x = x.flatten(1)
  
              for fc in self.shared_fcs:
                  x = self.relu(fc(x))
          # separate branches
          x_cls = x
          x_iou = x
          x_reg = x
  
          for conv in self.cls_convs:
              x_cls = conv(x_cls)
          if x_cls.dim() > 2:
              if self.with_avg_pool:
                  x_cls = self.avg_pool(x_cls)
              x_cls = x_cls.flatten(1)
          for fc in self.cls_fcs:
              x_cls = self.relu(fc(x_cls))
  
          for conv in self.iou_convs:
              x_iou = conv(x_iou)
          if x_iou.dim() > 2:
              if self.with_avg_pool:
                  x_iou = self.avg_pool(x_iou)
              x_iou = x_iou.flatten(1)
          for fc in self.iou_fcs:
              x_iou = self.relu(fc(x_iou))
  
          for conv in self.reg_convs:
              x_reg = conv(x_reg)
          if x_reg.dim() > 2:
              if self.with_avg_pool:
                  x_reg = self.avg_pool(x_reg)
              x_reg = x_reg.flatten(1)
          for fc in self.reg_fcs:
              x_reg = self.relu(fc(x_reg))
  
          cls_score = self.fc_cls(x_cls) if self.with_cls else None
          iou_score = self.fc_iou(x_iou) if self.with_iou else None
          bbox_pred = self.fc_reg(x_reg) if self.with_reg else None
          return cls_score, bbox_pred, iou_score
  
  
  @HEADS.register_module()
  class ConvParallelBBoxHead(BBoxParallelHead):
      r"""More general bbox head, with shared conv and fc layers and two optional
      separated branches.
  
      .. code-block:: none
  
                                      /-> cls convs -> cls fcs -> cls
          shared convs -> shared fcs  --> iou convs -> iou fcs -> iou
                                      \-> reg convs -> reg fcs -> reg
  
      """  # noqa: W605
  
      def __init__(self,
                   num_shared_convs=0,
                   num_shared_fcs_up=0,
                   num_shared_fcs_down=0,
                   num_cls_convs=0,
                   num_cls_fcs=0,
                   num_iou_convs=0,
                   num_iou_fcs=0,
                   num_reg_convs=0,
                   num_reg_fcs=0,
                   conv_out_channels=256,
                   fc_out_channels=1024,
                   conv_cfg=None,
                   norm_cfg=None,
                   train_cfg=None,
                   test_cfg=None,
                   *args,
                   **kwargs):
          super(ConvParallelBBoxHead, self).__init__(*args, **kwargs)
          assert (num_shared_convs + num_shared_fcs_up + num_shared_fcs_up + num_cls_convs +
                  num_cls_fcs + num_cls_convs + num_iou_convs + num_iou_fcs + num_reg_convs + num_reg_fcs > 0)
          if num_cls_convs > 0 or num_reg_convs > 0:
              assert num_shared_fcs_up == 0
              assert num_shared_fcs_down == 0
          if not self.with_cls:
              assert num_cls_convs == 0 and num_cls_fcs == 0
          if not self.with_iou:
              assert num_iou_convs == 0 and num_iou_fcs == 0
          if not self.with_reg:
              assert num_reg_convs == 0 and num_reg_fcs == 0
          self.num_shared_convs = num_shared_convs
          self.num_shared_fcs_up = num_shared_fcs_up
          self.num_shared_fcs_down = num_shared_fcs_down
          self.num_cls_convs = num_cls_convs
          self.num_cls_fcs = num_cls_fcs
          # 自己加的代码
          self.num_iou_convs = num_iou_convs
          self.num_iou_fcs = num_iou_fcs
          self.num_reg_convs = num_reg_convs
          self.num_reg_fcs = num_reg_fcs
          self.conv_out_channels = conv_out_channels
          self.fc_out_channels = fc_out_channels
          self.conv_cfg = conv_cfg
          self.norm_cfg = norm_cfg
          # 自己加的代码
          self.train_cfg = train_cfg
          self.test_cfg = test_cfg
  
          if self.train_cfg:
              self.bbox_assigner = build_assigner(self.train_cfg.assigner)
              self.bbox_sampler = build_sampler(
                  self.train_cfg.sampler, context=self)
  
          # add shared convs and fcs
          self.shared_convs, self.shared_fcs_up, last_layer_dim_up = \
              self._add_conv_fc_branch(
                  self.num_shared_convs, self.num_shared_fcs_up, self.in_channels,
                  True)
          self.shared_convs, self.shared_fcs_down, last_layer_dim_down = \
              self._add_conv_fc_branch(
                  self.num_shared_convs, self.num_shared_fcs_up, self.in_channels,
                  True)
  
          self.shared_out_channels_up = last_layer_dim_up
          self.shared_out_channels_down = last_layer_dim_down
  
          # add cls specific branch
          self.cls_convs, self.cls_fcs, self.cls_last_dim = \
              self._add_conv_fc_branch(
                  self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels_down)
  
          # add iou specific branch
          # 自己添加的代码
          self.iou_convs, self.iou_fcs, self.iou_last_dim = \
              self._add_conv_fc_branch(
                  self.num_iou_convs, self.num_iou_fcs, self.shared_out_channels_up)
  
          # add reg specific branch
          self.reg_convs, self.reg_fcs, self.reg_last_dim = \
              self._add_conv_fc_branch(
                  self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels_down)
  
          if self.num_shared_fcs_down == 0 and not self.with_avg_pool:
              if self.num_cls_fcs == 0:
                  self.cls_last_dim *= self.roi_feat_area
              if self.num_reg_fcs == 0:
                  self.reg_last_dim *= self.roi_feat_area
          if self.num_shared_fcs_up == 0 and not self.with_avg_pool:
              if self.num_iou_fcs == 0:
                  self.iou_last_dim *= self.roi_feat_area
  
          self.relu = nn.ReLU(inplace=True)
          # reconstruct fc_cls and fc_reg since input channels are changed
          if self.with_cls:
              self.fc_cls = nn.Linear(self.cls_last_dim, self.num_classes + 1)
          # 自己加的代码
          if self.with_iou:
              self.fc_iou = nn.Linear(self.iou_last_dim, 1)
  
          if self.with_reg:
              out_dim_reg = (4 if self.reg_class_agnostic else 4 * self.num_classes)
              self.fc_reg = nn.Linear(self.reg_last_dim, out_dim_reg)
  
      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_weights(self):
          super(ConvParallelBBoxHead, self).init_weights()
          # conv layers are already initialized by ConvModule
          for module_list in [self.shared_fcs_up, self.shared_fcs_down, self.cls_fcs, self.iou_fcs, self.reg_fcs]:  # 改了代码
              for m in module_list.modules():
                  if isinstance(m, nn.Linear):
                      nn.init.xavier_uniform_(m.weight)
                      nn.init.constant_(m.bias, 0)
  
      def forward(self, x):
          # shared part
          if self.num_shared_convs > 0:
              for conv in self.shared_convs:
                  x = conv(x)
  
          if self.num_shared_fcs_down > 0:
              x_down = x
              if self.with_avg_pool:
                  x_down = self.avg_pool(x_down)
  
              x_down = x_down.flatten(1)
  
              for fc in self.shared_fcs_down:
                  x_down = self.relu(fc(x_down))
  
          if self.num_shared_fcs_up > 0:
              x_up = x
              if self.with_avg_pool:
                  x_up = self.avg_pool(x_up)
  
              x_up = x_up.flatten(1)
  
              for fc in self.shared_fcs_up:
                  x_up = self.relu(fc(x_up))
  
          # separate branches
          x_cls = x_down
          x_iou = x_up  # 自己改的代码
          x_reg = x_down
  
          for conv in self.cls_convs:
              x_cls = conv(x_cls)
          if x_cls.dim() > 2:
              if self.with_avg_pool:
                  x_cls = self.avg_pool(x_cls)
              x_cls = x_cls.flatten(1)
          for fc in self.cls_fcs:
              x_cls = self.relu(fc(x_cls))
  
          # 自己改的代码
          for conv in self.iou_convs:
              x_iou = conv(x_iou)
              if x_iou.dim() > 2:
                  if self.with_avg_pool:
                      x_iou = self.avg_pool(x_iou)
                  x_iou = x_iou.flatten(1)
              for fc in self.iou_fcs:
                  x_iou = self.relu(fc(x_iou))
  
          for conv in self.reg_convs:
              x_reg = conv(x_reg)
          if x_reg.dim() > 2:
              if self.with_avg_pool:
                  x_reg = self.avg_pool(x_reg)
              x_reg = x_reg.flatten(1)
          for fc in self.reg_fcs:
              x_reg = self.relu(fc(x_reg))
  
          cls_score = self.fc_cls(x_cls) if self.with_cls else None
          iou_score = self.fc_iou(x_iou) if self.with_iou else None  # 改代码
          bbox_pred = self.fc_reg(x_reg) if self.with_reg else None
          return cls_score, iou_score, bbox_pred
  
  
  @HEADS.register_module()
  class Shared2FCBBoxHead(ConvFCBBoxHead):
  
      def __init__(self, fc_out_channels=1024, *args, **kwargs):
          super(Shared2FCBBoxHead, self).__init__(
              num_shared_convs=0,
              num_shared_fcs=2,
              num_cls_convs=0,
              num_cls_fcs=0,
              num_reg_convs=0,
              num_reg_fcs=0,
              fc_out_channels=fc_out_channels,
              *args,
              **kwargs)
  
  @HEADS.register_module()
  class SharedOneParallelFCBBoxHead(ConvOneParallelBBoxHead):
  
      def __init__(self, fc_out_channels=1024, *args, **kwargs):
          super(SharedOneParallelFCBBoxHead, self).__init__(
              num_shared_convs=0,
              num_shared_fcs=2,
              num_cls_convs=0,
              num_cls_fcs=0,
              # 自己加的代码
              num_iou_convs=0,
              num_iou_fcs=0,
              num_reg_convs=0,
              num_reg_fcs=0,
              fc_out_channels=fc_out_channels,
              *args,
              **kwargs)
  
  
  @HEADS.register_module()
  class SharedParallelFCBBoxHead(ConvParallelBBoxHead):
  
      def __init__(self, fc_out_channels=1024, *args, **kwargs):
          super(SharedParallelFCBBoxHead, self).__init__(
              num_shared_convs=0,
              num_shared_fcs_up=2,
              num_shared_fcs_down=2,  # 自己的代码
              num_cls_convs=0,
              num_cls_fcs=0,
              # 自己加的代码
              num_iou_convs=0,
              num_iou_fcs=0,
              num_reg_convs=0,
              num_reg_fcs=0,
              fc_out_channels=fc_out_channels,
              # 自己加的代码
              train_cfg=None,
              test_cfg=None,
              *args,
              **kwargs)
  
  
  @HEADS.register_module()
  class Shared4Conv1FCBBoxHead(ConvFCBBoxHead):
  
      def __init__(self, fc_out_channels=1024, *args, **kwargs):
          super(Shared4Conv1FCBBoxHead, self).__init__(
              num_shared_convs=4,
              num_shared_fcs=1,
              num_cls_convs=0,
              num_cls_fcs=0,
              num_reg_convs=0,
              num_reg_fcs=0,
              fc_out_channels=fc_out_channels,
              *args,
              **kwargs)
  