class_docstr: The Xception backobne of DeepLabv3+ implementation based on PaddlePaddle.
  
  The original article refers to
   Liang-Chieh Chen, et, al. "Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation"
   (https://arxiv.org/abs/1802.02611)
  
   Args:
       backbone (str): Which type of Xception_DeepLab to select. It should be one of ('xception_41', 'xception_65', 'xception_71').
       in_channels (int, optional): The channels of input image. Default: 3.
       pretrained (str, optional): The path of pretrained model.
       output_stride (int, optional): The stride of output features compared to input images. It is 8 or 16. Default: 16.
code: def __init__(
      self, backbone, in_channels=3, pretrained=None, output_stride=16
  ):
      super(XceptionDeeplab, self).__init__()
  
      bottleneck_params = gen_bottleneck_params(backbone)
      self.backbone = backbone
      self.feat_channels = [128, 2048]
  
      self._conv1 = ConvBNLayer(
          in_channels,
          32,
          3,
          stride=2,
          padding=1,
          act="relu",
          name=self.backbone + "/entry_flow/conv1",
      )
      self._conv2 = ConvBNLayer(
          32,
          64,
          3,
          stride=1,
          padding=1,
          act="relu",
          name=self.backbone + "/entry_flow/conv2",
      )
      """
              bottleneck_params = {
              "entry_flow": (3, [2, 2, 2], [128, 256, 728]),
              "middle_flow": (16, 1, 728),
              "exit_flow": (2, [2, 1], [[728, 1024, 1024], [1536, 1536, 2048]])
          }
  
          if output_stride == 16:
              entry_block3_stride = 2
              middle_block_dilation = 1
              exit_block_dilations = (1, 2)
          elif output_stride == 8:
              entry_block3_stride = 1
              middle_block_dilation = 2
              exit_block_dilations = (2, 4)
  
          """
      self.block_num = bottleneck_params["entry_flow"][0]
      self.strides = bottleneck_params["entry_flow"][1]
      self.chns = bottleneck_params["entry_flow"][2]
      self.strides = check_data(self.strides, self.block_num)
      self.chns = check_data(self.chns, self.block_num)
  
      self.entry_flow = []
      self.middle_flow = []
  
      self.stride = 2
      self.output_stride = output_stride
      s = self.stride
  
      for i in range(self.block_num):
          stride = (
              self.strides[i]
              if check_stride(s * self.strides[i], self.output_stride)
              else 1
          )
          xception_block = self.add_sublayer(
              self.backbone + "/entry_flow/block" + str(i + 1),
              Xception_Block(
                  input_channels=64 if i == 0 else self.chns[i - 1],
                  output_channels=self.chns[i],
                  strides=[1, 1, self.stride],
                  name=self.backbone + "/entry_flow/block" + str(i + 1),
              ),
          )
          self.entry_flow.append(xception_block)
          s = s * stride
      self.stride = s
  
      self.block_num = bottleneck_params["middle_flow"][0]
      self.strides = bottleneck_params["middle_flow"][1]
      self.chns = bottleneck_params["middle_flow"][2]
      self.strides = check_data(self.strides, self.block_num)
      self.chns = check_data(self.chns, self.block_num)
      s = self.stride
  
      for i in range(self.block_num):
          stride = (
              self.strides[i]
              if check_stride(s * self.strides[i], self.output_stride)
              else 1
          )
          xception_block = self.add_sublayer(
              self.backbone + "/middle_flow/block" + str(i + 1),
              Xception_Block(
                  input_channels=728,
                  output_channels=728,
                  strides=[1, 1, self.strides[i]],
                  skip_conv=False,
                  name=self.backbone
                  + "/middle_flow/block"
                  + str(i + 1),
              ),
          )
          self.middle_flow.append(xception_block)
          s = s * stride
      self.stride = s
  
      self.block_num = bottleneck_params["exit_flow"][0]
      self.strides = bottleneck_params["exit_flow"][1]
      self.chns = bottleneck_params["exit_flow"][2]
      self.strides = check_data(self.strides, self.block_num)
      self.chns = check_data(self.chns, self.block_num)
      s = self.stride
      stride = (
          self.strides[0]
          if check_stride(s * self.strides[0], self.output_stride)
          else 1
      )
      self._exit_flow_1 = Xception_Block(
          728,
          self.chns[0],
          [1, 1, stride],
          name=self.backbone + "/exit_flow/block1",
      )
      s = s * stride
      stride = (
          self.strides[1]
          if check_stride(s * self.strides[1], self.output_stride)
          else 1
      )
      self._exit_flow_2 = Xception_Block(
          self.chns[0][-1],
          self.chns[1],
          [1, 1, stride],
          dilation=2,
          has_skip=False,
          activation_fn_in_separable_conv=True,
          name=self.backbone + "/exit_flow/block2",
      )
  
      self.pretrained = pretrained
      self.init_weight()
  
imports: import paddle.nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager
  from paddleseg.utils import utils
  from paddleseg.models import layers
label_desc: Use image node_id 1 to create a new XceptionDeeplab object from inherited base classes: nn with example: obj = XceptionDeeplab(backbone, in_channels, pretrained, output_stride)