code: def forward(self, conv_out, segSize=None):
      conv5 = conv_out[-1]
  
      input_size = conv5.size()
      ppm_out = [conv5]
      for pool_scale, pool_conv in zip(self.ppm_pooling, self.ppm_conv):
          ppm_out.append(
              pool_conv(
                  nn.functional.upsample(
                      pool_scale(conv5),
                      (input_size[2], input_size[3]),
                      mode="bilinear",
                  )
              )
          )
      ppm_out = torch.cat(ppm_out, 1)
      f = self.ppm_last_conv(ppm_out)
  
      fpn_feature_list = [f]
      for i in reversed(range(len(conv_out) - 1)):
          conv_x = conv_out[i]
          conv_x = self.fpn_in[i](conv_x)  # lateral branch
  
          f = nn.functional.upsample(
              f, size=conv_x.size()[2:], mode="bilinear"
          )  # top-down branch
          f = conv_x + f
  
          fpn_feature_list.append(self.fpn_out[i](f))
  
      fpn_feature_list.reverse()  # [P2 - P5]
      output_size = fpn_feature_list[0].size()[2:]
      fusion_list = [fpn_feature_list[0]]
      for i in range(1, len(fpn_feature_list)):
          fusion_list.append(
              nn.functional.upsample(
                  fpn_feature_list[i], output_size, mode="bilinear"
              )
          )
      fusion_out = torch.cat(fusion_list, 1)
      x = self.conv_last(fusion_out)
  
      if self.use_softmax:  # is True during inference
          x = nn.functional.upsample(x, size=segSize, mode="bilinear")
          x = nn.functional.softmax(x, dim=1)
          return x
  
      x = nn.functional.log_softmax(x, dim=1)
  
      return x
  
imports: import torch
  import torch.nn
  import torch.nn.functional
  from .None import seg_resnet
  from .None import seg_resnext
label_desc: Use image node_id 2 for calling the UPerNet obj's underlying member method code with example usage: obj.forward(conv_out, segSize) and returns: x, x