class_docstr: NAS-FPN.
  
  Implementation of `NAS-FPN: Learning Scalable Feature Pyramid Architecture
  for Object Detection <https://arxiv.org/abs/1904.07392>`_
  
  Args:
      in_channels (List[int]): Number of input channels per scale.
      out_channels (int): Number of output channels (used at each scale)
      num_outs (int): Number of output scales.
      stack_times (int): The number of times the pyramid architecture will
          be stacked.
      start_level (int): Index of the start input backbone level used to
          build the feature pyramid. Default: 0.
      end_level (int): Index of the end input backbone level (exclusive) to
          build the feature pyramid. Default: -1, which means the last level.
      add_extra_convs (bool): It decides whether to add conv
          layers on top of the original feature maps. Default to False.
          If True, its actual mode is specified by `extra_convs_on_inputs`.
code: 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,
              act_cfg=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,
              act_cfg=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"] = GlobalPoolingCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # sum(p4_1, p4) -> p4_2
          stage["sum_44_4"] = SumCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # sum(p4_2, p3) -> p3_out
          stage["sum_43_3"] = SumCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # sum(p3_out, p4_2) -> p4_out
          stage["sum_34_4"] = SumCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # sum(p5, gp(p4_out, p3_out)) -> p5_out
          stage["gp_43_5"] = GlobalPoolingCell(with_out_conv=False)
          stage["sum_55_5"] = SumCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # sum(p7, gp(p5_out, p4_2)) -> p7_out
          stage["gp_54_7"] = GlobalPoolingCell(with_out_conv=False)
          stage["sum_77_7"] = SumCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          # gp(p7_out, p5_out) -> p6_out
          stage["gp_75_6"] = GlobalPoolingCell(
              in_channels=out_channels,
              out_channels=out_channels,
              out_norm_cfg=norm_cfg,
          )
          self.fpn_stages.append(stage)
  
file_path: insightface/detection/scrfd/mmdet/models/necks/nas_fpn.py
imports: import torch.nn
  from mmcv.cnn import ConvModule, caffe2_xavier_init
  from mmcv.ops.merge_cells import GlobalPoolingCell, SumCell
  from ..builder import NECKS
label_desc: Use image node_id 1 to create a new NASFPN object from inherited base classes: nn with example: obj = NASFPN(in_channels, out_channels, num_outs, stack_times, start_level, end_level, add_extra_convs, norm_cfg)