class_docstr: Args:
      in_channels (int): Number of channels of input image tensor.
      layers (list[int]): List of BasicBlock number for each stage.
      channels (list[int]): List of out_channels of Conv2d layer.
      out_indices (None | Sequence[int]): Indices of output stages.
      last_stage_pool (bool): If True, add `MaxPool2d` layer to last stage.
      init_type (None | str): the config to control the initialization.
class_docstr_tok: ["Args",":","in_channels","(","int",")",":","Number","of","channels","of","input","image","tensor",".","layers","(","list","[","int","]",")",":","List","of","BasicBlock","number","for","each","stage",".","channels","(","list","[","int","]",")",":","List","of","out_channels","of","Conv2d","layer",".","out_indices","(","None","|","Sequence","[","int","]",")",":","Indices","of","output","stages",".","last_stage_pool","(","bool",")",":","If","True",",","add","`","MaxPool2d","`","layer","to","last","stage",".","init_type","(","None","|","str",")",":","the","config","to","control","the","initialization","."]
code: def __init__(
      self,
      in_channels=3,
      layers=[1, 2, 5, 3],
      channels=[64, 128, 256, 256, 512, 512, 512],
      out_indices=None,
      last_stage_pool=False,
      init_type=None,
  ):
      super(ResNet31, self).__init__()
      assert isinstance(in_channels, int)
      assert isinstance(last_stage_pool, bool)
  
      self.out_indices = out_indices
      self.last_stage_pool = last_stage_pool
  
      conv_weight_attr = None
      bn_weight_attr = None
  
      if init_type is not None:
          support_dict = ["KaimingNormal"]
          assert init_type in support_dict, Exception(
              "resnet31 only support {}".format(support_dict)
          )
          conv_weight_attr = nn.initializer.KaimingNormal()
          bn_weight_attr = ParamAttr(
              initializer=nn.initializer.Uniform(), learning_rate=1
          )
  
      # conv 1 (Conv Conv)
      self.conv1_1 = nn.Conv2D(
          in_channels,
          channels[0],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn1_1 = nn.BatchNorm2D(
          channels[0], weight_attr=bn_weight_attr
      )
      self.relu1_1 = nn.ReLU()
  
      self.conv1_2 = nn.Conv2D(
          channels[0],
          channels[1],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn1_2 = nn.BatchNorm2D(
          channels[1], weight_attr=bn_weight_attr
      )
      self.relu1_2 = nn.ReLU()
  
      # conv 2 (Max-pooling, Residual block, Conv)
      self.pool2 = nn.MaxPool2D(
          kernel_size=2, stride=2, padding=0, ceil_mode=True
      )
      self.block2 = self._make_layer(
          channels[1],
          channels[2],
          layers[0],
          conv_weight_attr=conv_weight_attr,
          bn_weight_attr=bn_weight_attr,
      )
      self.conv2 = nn.Conv2D(
          channels[2],
          channels[2],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn2 = nn.BatchNorm2D(channels[2], weight_attr=bn_weight_attr)
      self.relu2 = nn.ReLU()
  
      # conv 3 (Max-pooling, Residual block, Conv)
      self.pool3 = nn.MaxPool2D(
          kernel_size=2, stride=2, padding=0, ceil_mode=True
      )
      self.block3 = self._make_layer(
          channels[2],
          channels[3],
          layers[1],
          conv_weight_attr=conv_weight_attr,
          bn_weight_attr=bn_weight_attr,
      )
      self.conv3 = nn.Conv2D(
          channels[3],
          channels[3],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn3 = nn.BatchNorm2D(channels[3], weight_attr=bn_weight_attr)
      self.relu3 = nn.ReLU()
  
      # conv 4 (Max-pooling, Residual block, Conv)
      self.pool4 = nn.MaxPool2D(
          kernel_size=(2, 1), stride=(2, 1), padding=0, ceil_mode=True
      )
      self.block4 = self._make_layer(
          channels[3],
          channels[4],
          layers[2],
          conv_weight_attr=conv_weight_attr,
          bn_weight_attr=bn_weight_attr,
      )
      self.conv4 = nn.Conv2D(
          channels[4],
          channels[4],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn4 = nn.BatchNorm2D(channels[4], weight_attr=bn_weight_attr)
      self.relu4 = nn.ReLU()
  
      # conv 5 ((Max-pooling), Residual block, Conv)
      self.pool5 = None
      if self.last_stage_pool:
          self.pool5 = nn.MaxPool2D(
              kernel_size=2, stride=2, padding=0, ceil_mode=True
          )
      self.block5 = self._make_layer(
          channels[4],
          channels[5],
          layers[3],
          conv_weight_attr=conv_weight_attr,
          bn_weight_attr=bn_weight_attr,
      )
      self.conv5 = nn.Conv2D(
          channels[5],
          channels[5],
          kernel_size=3,
          stride=1,
          padding=1,
          weight_attr=conv_weight_attr,
      )
      self.bn5 = nn.BatchNorm2D(channels[5], weight_attr=bn_weight_attr)
      self.relu5 = nn.ReLU()
  
      self.out_channels = channels[-1]
  
file_path: PaddleOCR/ppocr/modeling/backbones/rec_resnet_31.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  from paddle import ParamAttr
  import paddle.nn
  import paddle.nn.functional
  import numpy
label_desc: Use image node_id 1 to create a new ResNet31 object from inherited base classes: nn with example: obj = ResNet31(in_channels, layers, channels, out_indices, last_stage_pool, init_type)