code: def forward(self, inputs):
      laterals = []
      for i, lateral_conv in enumerate(self.lateral_convs):
          laterals.append(lateral_conv(inputs[i]))
  
      laterals.append(self.ppm(inputs[-1]))
      fpn_levels = len(laterals)
      for i in range(fpn_levels - 1, 0, -1):
          prev_shape = paddle.shape(laterals[i - 1])
          laterals[i - 1] = laterals[i - 1] + F.interpolate(
              laterals[i],
              size=prev_shape[2:],
              mode="bilinear",
              align_corners=self.align_corners,
          )
  
      fpn_outs = []
      for i in range(fpn_levels - 1):
          fpn_outs.append(self.fpn_convs[i](laterals[i]))
      fpn_outs.append(laterals[-1])
  
      for i in range(fpn_levels - 1, 0, -1):
          fpn_outs[i] = F.interpolate(
              fpn_outs[i],
              size=paddle.shape(fpn_outs[0])[2:],
              mode="bilinear",
              align_corners=self.align_corners,
          )
      fuse_out = paddle.concat(fpn_outs, axis=1)
      feats = self.fpn_bottleneck(fuse_out)
      output = self.conv_seg(feats)
      if self.training:
          seg_kernels = self.conv_seg.weight.clone()
      else:
          # Since tensor.clone() raises error when exporting static model, we use tensor instead,
          # although this may cause little performance drop in mIoU.
          seg_kernels = self.conv_seg.weight
      seg_kernels = seg_kernels[None].expand(
          [paddle.shape(feats)[0], *paddle.shape(seg_kernels)]
      )
      return output, feats, seg_kernels
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddleseg import utils
  from paddleseg.cvlibs import manager
  from paddleseg.models import layers
  from .upernet import UPerNetHead
label_desc: Use image node_id 1 for calling the UPerKernelHead obj's underlying member method code with example usage: obj.forward(inputs) and returns: output,  feats,  seg_kernels