code: def __init__(self, in_channels):
      super(FPN_Up_Fusion, self).__init__()
      in_channels = in_channels[::-1]
      out_channels = [256, 256, 192, 192, 128]
  
      self.h0_conv = ConvBNLayer(
          in_channels[0],
          out_channels[0],
          1,
          1,
          act=None,
          name="fpn_up_h0",
      )
      self.h1_conv = ConvBNLayer(
          in_channels[1],
          out_channels[1],
          1,
          1,
          act=None,
          name="fpn_up_h1",
      )
      self.h2_conv = ConvBNLayer(
          in_channels[2],
          out_channels[2],
          1,
          1,
          act=None,
          name="fpn_up_h2",
      )
      self.h3_conv = ConvBNLayer(
          in_channels[3],
          out_channels[3],
          1,
          1,
          act=None,
          name="fpn_up_h3",
      )
      self.h4_conv = ConvBNLayer(
          in_channels[4],
          out_channels[4],
          1,
          1,
          act=None,
          name="fpn_up_h4",
      )
  
      self.g0_conv = DeConvBNLayer(
          out_channels[0],
          out_channels[1],
          4,
          2,
          act=None,
          name="fpn_up_g0",
      )
  
      self.g1_conv = nn.Sequential(
          ConvBNLayer(
              out_channels[1],
              out_channels[1],
              3,
              1,
              act="relu",
              name="fpn_up_g1_1",
          ),
          DeConvBNLayer(
              out_channels[1],
              out_channels[2],
              4,
              2,
              act=None,
              name="fpn_up_g1_2",
          ),
      )
      self.g2_conv = nn.Sequential(
          ConvBNLayer(
              out_channels[2],
              out_channels[2],
              3,
              1,
              act="relu",
              name="fpn_up_g2_1",
          ),
          DeConvBNLayer(
              out_channels[2],
              out_channels[3],
              4,
              2,
              act=None,
              name="fpn_up_g2_2",
          ),
      )
      self.g3_conv = nn.Sequential(
          ConvBNLayer(
              out_channels[3],
              out_channels[3],
              3,
              1,
              act="relu",
              name="fpn_up_g3_1",
          ),
          DeConvBNLayer(
              out_channels[3],
              out_channels[4],
              4,
              2,
              act=None,
              name="fpn_up_g3_2",
          ),
      )
  
      self.g4_conv = nn.Sequential(
          ConvBNLayer(
              out_channels[4],
              out_channels[4],
              3,
              1,
              act="relu",
              name="fpn_up_fusion_1",
          ),
          ConvBNLayer(
              out_channels[4],
              out_channels[4],
              1,
              1,
              act=None,
              name="fpn_up_fusion_2",
          ),
      )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  from paddle import nn
  import paddle.nn.functional
  from paddle import ParamAttr
label_desc: Use image node_id 1 to create a new FPN_Up_Fusion object from inherited base classes: nn with example: obj = FPN_Up_Fusion(in_channels)