docstr: PPYOLO Tiny FPN layer
  Args:
      in_channels (list): input channels for fpn
      detection_block_channels (list): channels in fpn
      norm_type (str): batch norm type, default bn
      data_format (str): data format, NCHW or NHWC
      kwargs: extra key-value pairs, such as parameter of DropBlock and spp 
docstr_tok: ["PPYOLO","Tiny","FPN","layer","Args",":","in_channels","(","list",")",":","input","channels","for","fpn","detection_block_channels","(","list",")",":","channels","in","fpn","norm_type","(","str",")",":","batch","norm","type",",","default","bn","data_format","(","str",")",":","data","format",",","NCHW","or","NHWC","kwargs",":","extra","key-value","pairs",",","such","as","parameter","of","DropBlock","and","spp"]
code: def __init__(
      self,
      in_channels=[80, 56, 34],
      detection_block_channels=[160, 128, 96],
      norm_type="bn",
      data_format="NCHW",
      **kwargs,
  ):
      """
      PPYOLO Tiny FPN layer
      Args:
          in_channels (list): input channels for fpn
          detection_block_channels (list): channels in fpn
          norm_type (str): batch norm type, default bn
          data_format (str): data format, NCHW or NHWC
          kwargs: extra key-value pairs, such as parameter of DropBlock and spp
      """
      super(PPYOLOTinyFPN, self).__init__()
      assert len(in_channels) > 0, "in_channels length should > 0"
      self.in_channels = in_channels[::-1]
      assert (
          len(detection_block_channels) > 0
      ), "detection_block_channelslength should > 0"
      self.detection_block_channels = detection_block_channels
      self.data_format = data_format
      self.num_blocks = len(in_channels)
      # parse kwargs
      self.drop_block = kwargs.get("drop_block", False)
      self.block_size = kwargs.get("block_size", 3)
      self.keep_prob = kwargs.get("keep_prob", 0.9)
  
      self.spp_ = kwargs.get("spp", False)
      if self.spp_:
          self.spp = SPP(
              self.in_channels[0] * 4,
              self.in_channels[0],
              k=1,
              pool_size=[5, 9, 13],
              norm_type=norm_type,
              name="spp",
          )
  
      self._out_channels = []
      self.yolo_blocks = []
      self.routes = []
      for i, (ch_in, ch_out) in enumerate(
          zip(self.in_channels, self.detection_block_channels)
      ):
          name = "yolo_block.{}".format(i)
          if i > 0:
              ch_in += self.detection_block_channels[i - 1]
          yolo_block = self.add_sublayer(
              name,
              PPYOLOTinyDetBlock(
                  ch_in,
                  ch_out,
                  name,
                  drop_block=self.drop_block,
                  block_size=self.block_size,
                  keep_prob=self.keep_prob,
              ),
          )
          self.yolo_blocks.append(yolo_block)
          self._out_channels.append(ch_out)
  
          if i < self.num_blocks - 1:
              name = "yolo_transition.{}".format(i)
              route = self.add_sublayer(
                  name,
                  ConvBNLayer(
                      ch_in=ch_out,
                      ch_out=ch_out,
                      filter_size=1,
                      stride=1,
                      padding=0,
                      norm_type=norm_type,
                      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 PPYOLOTinyFPN object from inherited base classes: nn with example: obj = PPYOLOTinyFPN(in_channels, detection_block_channels, norm_type, data_format)