class_docstr: Semantic segmentation model with a light R-ASPP head.
  
  The original article refers to
      Howard, Andrew, et al. "Searching for mobilenetv3."
      (https://arxiv.org/pdf/1909.11065.pdf)
  
  Args:
      num_classes (int): The number of target classes.
      backbone(nn.Layer): Backbone network, such as stdc1net and resnet18. The backbone must
          has feat_channels, of which the length is 5.
      backbone_indices (List(int), optional): The values indicate the indices of backbone output 
          used as the input of the LR-ASPP head.
          Default: [0, 1, 3].
      lraspp_head_inter_chs (List(int), optional): The intermediate channels of LR-ASPP head.
          Default: [32, 64].
      lraspp_head_out_ch (int, optional): The output channels of each ASPP branch in the LR-ASPP head.
          Default: 128
      resize_mode (str, optional): The resize mode for the upsampling operation in the LR-ASPP head.
          Default: bilinear.
      use_gap (bool, optional): If true, use global average pooling in the LR-ASPP head; otherwise, use
          a 49x49 kernel for average pooling.
          Default: True.
      pretrained (str, optional): The path or url of pretrained model. Default: None.
code: def __init__(
      self,
      num_classes,
      backbone,
      backbone_indices=[0, 1, 3],
      lraspp_head_inter_chs=[32, 64],
      lraspp_head_out_ch=128,
      resize_mode="bilinear",
      use_gap=True,
      pretrained=None,
  ):
      super().__init__()
  
      # backbone
      assert hasattr(
          backbone, "feat_channels"
      ), "The backbone should has feat_channels."
      assert len(backbone.feat_channels) >= len(backbone_indices), (
          f"The length of input backbone_indices ({len(backbone_indices)}) should not be"
          f"greater than the length of feat_channels ({len(backbone.feat_channels)})."
      )
      assert len(backbone.feat_channels) > max(backbone_indices), (
          f"The max value ({max(backbone_indices)}) of backbone_indices should be "
          f"less than the length of feat_channels ({len(backbone.feat_channels)})."
      )
      self.backbone = backbone
  
      assert len(backbone_indices) >= 1, (
          "The lenght of backbone_indices "
          "should not be lesser than 1"
      )
  
      # head
      assert (
          len(backbone_indices) == len(lraspp_head_inter_chs) + 1
      ), "The length of backbone_indices should be 1 greater than lraspp_head_inter_chs."
      self.backbone_indices = backbone_indices
  
      self.lraspp_head = LRASPPHead(
          backbone_indices,
          backbone.feat_channels,
          lraspp_head_inter_chs,
          lraspp_head_out_ch,
          num_classes,
          resize_mode,
          use_gap,
      )
  
      # pretrained
      self.pretrained = pretrained
      self.init_weight()
  
file_path: PaddleSeg/paddleseg/models/lraspp.py
imports: from functools import partial
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddleseg import utils
  from paddleseg.models import layers
  from paddleseg.cvlibs import manager
label_desc: Use image node_id 1 to create a new LRASPP object from inherited base classes: nn with example: obj = LRASPP(num_classes, backbone, backbone_indices, lraspp_head_inter_chs, lraspp_head_out_ch, resize_mode, use_gap, pretrained)