class_docstr: The DDRNet implementation based on PaddlePaddle.
  
  The original article refers to
  Yuanduo Hong, Huihui Pan, Weichao Sun, et al. "Deep Dual-resolution Networks for Real-time and Accurate Semantic Segmentation of Road Scenes"
  (https://arxiv.org/abs/2101.06085)
  
  Args:
      num_classes (int): The unique number of target classes.
      in_channels (int, optional): Number of input channels. Default: 3.
      block_layers (list, tuple): The numbers of layers in different blocks. Default: [2, 2, 2, 2].
      planes (int): Base channels in network. Default: 64.
      spp_planes (int): Branch channels for DAPPM. Default: 128.
      head_planes (int): Mid channels of segmentation head. Default: 128.
      enable_auxiliary_loss (bool): Whether use auxiliary head for stage3. Default: False.
      pretrained (str, optional): The path or url of pretrained model. Default: None.
code: def forward(self, x):
      n, c, h, w = paddle.shape(x)
      width_output = w // 8
      height_output = h // 8
  
      x = self.conv1(x)
      stage1_out = self.layer1(x)
      stage2_out = self.layer2(self.relu(stage1_out))
      stage3_out = self.layer3(self.relu(stage2_out))
      stage3_out_dual = self.layer3_(self.relu(stage2_out))
      x = stage3_out + self.down3(self.relu(stage3_out_dual))
      stage3_merge = stage3_out_dual + F.interpolate(
          self.compression3(self.relu(stage3_out)),
          size=[height_output, width_output],
          mode="bilinear",
      )
  
      stage4_out = self.layer4(self.relu(x))
      stage4_out_dual = self.layer4_(self.relu(stage3_merge))
  
      x = stage4_out + self.down4(self.relu(stage4_out_dual))
      stage4_merge = stage4_out_dual + F.interpolate(
          self.compression4(self.relu(stage4_out)),
          size=[height_output, width_output],
          mode="bilinear",
      )
  
      stage5_out_dual = self.layer5_(self.relu(stage4_merge))
      x = F.interpolate(
          self.spp(self.layer5(self.relu(x))),
          size=[height_output, width_output],
          mode="bilinear",
      )
  
      output = self.head(x + stage5_out_dual)
      logit_list = []
      logit_list.append(output)
  
      if self.enable_auxiliary_loss:
          aux_out = self.aux_head(stage3_merge)
          logit_list.append(aux_out)
      return [
          F.interpolate(logit, [h, w], mode="bilinear")
          for logit in logit_list
      ]
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager, param_init
  from paddleseg.models import layers
  from paddleseg.utils import utils
label_desc: Use image node_id 4 for calling the DualResNet obj's underlying member method code with example usage: obj.forward(x) and returns: unknown