class_docstr: The GINetResNet50 implementation based on PaddlePaddle.
  The original article refers to
  Wu, Tianyi, Yu Lu, Yu Zhu, Chuang Zhang, Ming Wu, Zhanyu Ma, and Guodong Guo. "GINet: Graph interaction network for scene parsing." In European Conference on Computer Vision, pp. 34-51. Springer, Cham, 2020.
  (https://arxiv.org/pdf/2009.06160).
  Args:
      num_classes (int): The unique number of target classes.
      backbone_indices (tuple, optional): Values in the tuple indicate the indices of output of backbone.
      enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss.
          If true, auxiliary loss will be added after LearningToDownsample module. Default: False.
      align_corners (bool): An argument of F.interpolate. It should be set to False when the output size of feature
          is even, e.g. 1024x512, otherwise it is True, e.g. 769x769.. Default: False.
      jpu (bool, optional)): whether to use jpu unit in the base forward. Default:True.
      pretrained (str, optional): The path or url of pretrained model. Default: None.
code: def __init__(
      self,
      num_classes: int = 19,
      backbone_indices: Tuple[int] = (0, 1, 2, 3),
      enable_auxiliary_loss: bool = True,
      align_corners: bool = True,
      jpu: bool = True,
      pretrained: str = None,
  ):
      super(GINetResNet50, self).__init__()
      self.nclass = num_classes
      self.aux = enable_auxiliary_loss
      self.jpu = jpu
  
      self.backbone = ResNet50_vd()
      self.backbone_indices = backbone_indices
      self.align_corners = align_corners
      self.transforms = T.Compose([T.Normalize()])
  
      self.jpu = (
          layers.JPU([512, 1024, 2048], width=512) if jpu else None
      )
      self.head = GIHead(in_channels=2048, nclass=num_classes)
  
      if self.aux:
          self.auxlayer = layers.AuxLayer(
              1024, 1024 // 4, num_classes, bias_attr=False
          )
  
      if pretrained is not None:
          model_dict = paddle.load(pretrained)
          self.set_dict(model_dict)
          print("load custom parameters success")
  
      else:
          checkpoint = os.path.join(self.directory, "model.pdparams")
          model_dict = paddle.load(checkpoint)
          self.set_dict(model_dict)
          print("load pretrained parameters success")
  
imports: import os
  from typing import Union, List, Tuple
  import paddle
  from paddle import nn
  import paddle.nn.functional
  import numpy
  from paddlehub.module.module import moduleinfo
  import paddlehub.vision.segmentation_transforms
  from paddlehub.module.cv_module import ImageSegmentationModule
  from paddleseg.utils import utils
  from paddleseg.models import layers
  from ginet_resnet50vd_cityscapes.resnet import ResNet50_vd
label_desc: Use image node_id 1 to create a new GINetResNet50 object from inherited base classes: nn with example: obj = GINetResNet50(num_classes, backbone_indices, enable_auxiliary_loss, align_corners, jpu, pretrained)