docstr: PPYOLOFPN layer
  
  Args:
      in_channels (list): input channels for fpn
      norm_type (str): batch norm type, default bn
      data_format (str): data format, NCHW or NHWC
      coord_conv (bool): whether use CoordConv or not
      conv_block_num (int): conv block num of each pan block
      drop_block (bool): whether use DropBlock or not
      block_size (int): block size of DropBlock
      keep_prob (float): keep probability of DropBlock
      spp (bool): whether use spp or not
docstr_tok: ["PPYOLOFPN","layer","Args",":","in_channels","(","list",")",":","input","channels","for","fpn","norm_type","(","str",")",":","batch","norm","type",",","default","bn","data_format","(","str",")",":","data","format",",","NCHW","or","NHWC","coord_conv","(","bool",")",":","whether","use","CoordConv","or","not","conv_block_num","(","int",")",":","conv","block","num","of","each","pan","block","drop_block","(","bool",")",":","whether","use","DropBlock","or","not","block_size","(","int",")",":","block","size","of","DropBlock","keep_prob","(","float",")",":","keep","probability","of","DropBlock","spp","(","bool",")",":","whether","use","spp","or","not"]
code: def __init__(
      self,
      in_channels=[512, 1024, 2048],
      norm_type="bn",
      freeze_norm=False,
      data_format="NCHW",
      coord_conv=False,
      conv_block_num=2,
      drop_block=False,
      block_size=3,
      keep_prob=0.9,
      spp=False,
  ):
      """
      PPYOLOFPN layer
  
      Args:
          in_channels (list): input channels for fpn
          norm_type (str): batch norm type, default bn
          data_format (str): data format, NCHW or NHWC
          coord_conv (bool): whether use CoordConv or not
          conv_block_num (int): conv block num of each pan block
          drop_block (bool): whether use DropBlock or not
          block_size (int): block size of DropBlock
          keep_prob (float): keep probability of DropBlock
          spp (bool): whether use spp or not
  
      """
      super(PPYOLOFPN, self).__init__()
      assert len(in_channels) > 0, "in_channels length should > 0"
      self.in_channels = in_channels
      self.num_blocks = len(in_channels)
      # parse kwargs
      self.coord_conv = coord_conv
      self.drop_block = drop_block
      self.block_size = block_size
      self.keep_prob = keep_prob
      self.spp = spp
      self.conv_block_num = conv_block_num
      self.data_format = data_format
      if self.coord_conv:
          ConvLayer = CoordConv
      else:
          ConvLayer = ConvBNLayer
  
      if self.drop_block:
          dropblock_cfg = [
              [
                  "dropblock",
                  DropBlock,
                  [self.block_size, self.keep_prob],
                  dict(),
              ]
          ]
      else:
          dropblock_cfg = []
  
      self._out_channels = []
      self.yolo_blocks = []
      self.routes = []
      for i, ch_in in enumerate(self.in_channels[::-1]):
          if i > 0:
              ch_in += 512 // (2**i)
          channel = 64 * (2**self.num_blocks) // (2**i)
          base_cfg = []
          c_in, c_out = ch_in, channel
          for j in range(self.conv_block_num):
              base_cfg += [
                  [
                      "conv{}".format(2 * j),
                      ConvLayer,
                      [c_in, c_out, 1],
                      dict(
                          padding=0,
                          norm_type=norm_type,
                          freeze_norm=freeze_norm,
                      ),
                  ],
                  [
                      "conv{}".format(2 * j + 1),
                      ConvBNLayer,
                      [c_out, c_out * 2, 3],
                      dict(
                          padding=1,
                          norm_type=norm_type,
                          freeze_norm=freeze_norm,
                      ),
                  ],
              ]
              c_in, c_out = c_out * 2, c_out
  
          base_cfg += [
              [
                  "route",
                  ConvLayer,
                  [c_in, c_out, 1],
                  dict(
                      padding=0,
                      norm_type=norm_type,
                      freeze_norm=freeze_norm,
                  ),
              ],
              [
                  "tip",
                  ConvLayer,
                  [c_out, c_out * 2, 3],
                  dict(
                      padding=1,
                      norm_type=norm_type,
                      freeze_norm=freeze_norm,
                  ),
              ],
          ]
  
          if self.conv_block_num == 2:
              if i == 0:
                  if self.spp:
                      spp_cfg = [
                          [
                              "spp",
                              SPP,
                              [channel * 4, channel, 1],
                              dict(
                                  pool_size=[5, 9, 13],
                                  norm_type=norm_type,
                                  freeze_norm=freeze_norm,
                              ),
                          ]
                      ]
                  else:
                      spp_cfg = []
                  cfg = (
                      base_cfg[0:3]
                      + spp_cfg
                      + base_cfg[3:4]
                      + dropblock_cfg
                      + base_cfg[4:6]
                  )
              else:
                  cfg = base_cfg[0:2] + dropblock_cfg + base_cfg[2:6]
          elif self.conv_block_num == 0:
              if self.spp and i == 0:
                  spp_cfg = [
                      [
                          "spp",
                          SPP,
                          [c_in * 4, c_in, 1],
                          dict(
                              pool_size=[5, 9, 13],
                              norm_type=norm_type,
                              freeze_norm=freeze_norm,
                          ),
                      ]
                  ]
              else:
                  spp_cfg = []
              cfg = spp_cfg + dropblock_cfg + base_cfg
          name = "yolo_block.{}".format(i)
          yolo_block = self.add_sublayer(
              name, PPYOLODetBlock(cfg, name)
          )
          self.yolo_blocks.append(yolo_block)
          self._out_channels.append(channel * 2)
          if i < self.num_blocks - 1:
              name = "yolo_transition.{}".format(i)
              route = self.add_sublayer(
                  name,
                  ConvBNLayer(
                      ch_in=channel,
                      ch_out=256 // (2**i),
                      filter_size=1,
                      stride=1,
                      padding=0,
                      norm_type=norm_type,
                      freeze_norm=freeze_norm,
                      data_format=data_format,
                      name=name,
                  ),
              )
              self.routes.append(route)
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from ppdet.core.workspace import register, serializable
  from ppdet.modeling.layers import DropBlock
  from ppdet.modeling.ops import get_act_fn
  from ..backbones.darknet import ConvBNLayer
  from ..shape_spec import ShapeSpec
  from ..backbones.csp_darknet import BaseConv, DWConv, CSPLayer
label_desc: Use image node_id 1 to create a new PPYOLOFPN object from inherited base classes: nn with example: obj = PPYOLOFPN(in_channels, norm_type, freeze_norm, data_format, coord_conv, conv_block_num, drop_block, block_size, keep_prob, spp)