class_docstr: The neck of YOLOV3.
  
  It can be treated as a simplified version of FPN. It
  will take the result from Darknet backbone and do some upsampling and
  concatenation. It will finally output the detection result.
  
  Note:
      The input feats should be from top to bottom.
          i.e., from high-lvl to low-lvl
      But YOLOV3Neck will process them in reversed order.
          i.e., from bottom (high-lvl) to top (low-lvl)
  
  Args:
      num_scales (int): The number of scales / stages.
      in_channels (int): The number of input channels.
      out_channels (int): The number of output channels.
      conv_cfg (dict): Config dict for convolution layer. Default: None.
      norm_cfg (dict): Dictionary to construct and config norm layer.
          Default: dict(type='BN', requires_grad=True)
      act_cfg (dict): Config dict for activation layer.
          Default: dict(type='LeakyReLU', negative_slope=0.1).
code: def forward(self, feats):
      assert len(feats) == self.num_scales
  
      # processed from bottom (high-lvl) to top (low-lvl)
      outs = []
      out = self.detect1(feats[-1])
      outs.append(out)
  
      for i, x in enumerate(reversed(feats[:-1])):
          conv = getattr(self, f"conv{i+1}")
          tmp = conv(out)
  
          # Cat with low-lvl feats
          tmp = F.interpolate(tmp, scale_factor=2)
          tmp = torch.cat((tmp, x), 1)
  
          detect = getattr(self, f"detect{i+2}")
          out = detect(tmp)
          outs.append(out)
  
      return tuple(outs)
  
file_path: insightface/detection/scrfd/mmdet/models/necks/yolo_neck.py
imports: import torch
  import torch.nn
  import torch.nn.functional
  from mmcv.cnn import ConvModule
  from ..builder import NECKS
label_desc: Use image node_id 2 for calling the YOLOV3Neck obj's underlying member method code with example usage: obj.forward(feats) and returns: tuple