class_docstr: The ResNet_vd implementation based on PaddlePaddle.
  
  The original article refers to Jingdong
  Tong He, et, al. "Bag of Tricks for Image Classification with Convolutional Neural Networks"
  (https://arxiv.org/pdf/1812.01187.pdf).
  
  Args:
      layers (int, optional): The layers of ResNet_vd. The supported layers are (18, 34, 50, 101, 152, 200). Default: 50.
      output_stride (int, optional): The stride of output features compared to input images. It is 8 or 16. Default: 8.
      multi_grid (tuple|list, optional): The grid of stage4. Defult: (1, 1, 1).
      pretrained (str, optional): The path of pretrained model.
code: def __init__(
      self,
      input_channels=3,
      layers=50,
      output_stride=32,
      multi_grid=(1, 1, 1),
      pretrained=None,
  ):
      super(ResNet_vd, self).__init__()
  
      self.conv1_logit = None  # for gscnn shape stream
      self.layers = layers
      supported_layers = [18, 34, 50, 101, 152, 200]
      assert (
          layers in supported_layers
      ), "supported layers are {} but input layer is {}".format(
          supported_layers, layers
      )
  
      if layers == 18:
          depth = [2, 2, 2, 2]
      elif layers == 34 or layers == 50:
          depth = [3, 4, 6, 3]
      elif layers == 101:
          depth = [3, 4, 23, 3]
      elif layers == 152:
          depth = [3, 8, 36, 3]
      elif layers == 200:
          depth = [3, 12, 48, 3]
      num_channels = (
          [64, 256, 512, 1024] if layers >= 50 else [64, 64, 128, 256]
      )
      num_filters = [64, 128, 256, 512]
  
      # for channels of four returned stages
      self.feat_channels = (
          [c * 4 for c in num_filters] if layers >= 50 else num_filters
      )
      self.feat_channels = [64] + self.feat_channels
  
      dilation_dict = None
      if output_stride == 8:
          dilation_dict = {2: 2, 3: 4}
      elif output_stride == 16:
          dilation_dict = {3: 2}
  
      self.conv1_1 = ConvBNLayer(
          in_channels=input_channels,
          out_channels=32,
          kernel_size=3,
          stride=2,
          act="relu",
      )
      self.conv1_2 = ConvBNLayer(
          in_channels=32,
          out_channels=32,
          kernel_size=3,
          stride=1,
          act="relu",
      )
      self.conv1_3 = ConvBNLayer(
          in_channels=32,
          out_channels=64,
          kernel_size=3,
          stride=1,
          act="relu",
      )
      self.pool2d_max = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
  
      # self.block_list = []
      self.stage_list = []
      if layers >= 50:
          for block in range(len(depth)):
              shortcut = False
              block_list = []
              for i in range(depth[block]):
                  if layers in [101, 152] and block == 2:
                      if i == 0:
                          conv_name = "res" + str(block + 2) + "a"
                      else:
                          conv_name = (
                              "res" + str(block + 2) + "b" + str(i)
                          )
                  else:
                      conv_name = "res" + str(block + 2) + chr(97 + i)
  
                  ###############################################################################
                  # Add dilation rate for some segmentation tasks, if dilation_dict is not None.
                  dilation_rate = (
                      dilation_dict[block]
                      if dilation_dict and block in dilation_dict
                      else 1
                  )
  
                  # Actually block here is 'stage', and i is 'block' in 'stage'
                  # At the stage 4, expand the dilation_rate if given multi_grid
                  if block == 3:
                      dilation_rate = dilation_rate * multi_grid[i]
                  ###############################################################################
  
                  bottleneck_block = self.add_sublayer(
                      "bb_%d_%d" % (block, i),
                      BottleneckBlock(
                          in_channels=num_channels[block]
                          if i == 0
                          else num_filters[block] * 4,
                          out_channels=num_filters[block],
                          stride=2
                          if i == 0
                          and block != 0
                          and dilation_rate == 1
                          else 1,
                          shortcut=shortcut,
                          if_first=block == i == 0,
                          dilation=dilation_rate,
                      ),
                  )
  
                  block_list.append(bottleneck_block)
                  shortcut = True
              self.stage_list.append(block_list)
      else:
          for block in range(len(depth)):
              shortcut = False
              block_list = []
              for i in range(depth[block]):
                  conv_name = "res" + str(block + 2) + chr(97 + i)
                  basic_block = self.add_sublayer(
                      "bb_%d_%d" % (block, i),
                      BasicBlock(
                          in_channels=num_channels[block]
                          if i == 0
                          else num_filters[block],
                          out_channels=num_filters[block],
                          stride=2 if i == 0 and block != 0 else 1,
                          shortcut=shortcut,
                          if_first=block == i == 0,
                      ),
                  )
                  block_list.append(basic_block)
                  shortcut = True
              self.stage_list.append(block_list)
  
      self.pretrained = pretrained
      self.init_weight()
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager
  from paddleseg.models import layers
  import ppmatting
label_desc: Use image node_id 1 to create a new ResNet_vd object from inherited base classes: nn with example: obj = ResNet_vd(input_channels, layers, output_stride, multi_grid, pretrained)