docstr: Args:
      in_channels (int): input channel
      out_channels (int): output channel
docstr_tok: ["Args",":","in_channels","(","int",")",":","input","channel","out_channels","(","int",")",":","output","channel"]
code: def __init__(
      self, in_channels, out_channels=512, use_cnt=True, use_seq=True
  ):
      """
  
      Args:
          in_channels (int): input channel
          out_channels (int): output channel
      """
      super(ResNetRFL, self).__init__()
      assert use_cnt or use_seq
      self.use_cnt, self.use_seq = use_cnt, use_seq
      self.backbone = RFLBase(in_channels)
  
      self.out_channels = out_channels
      self.out_channels_block = [
          int(self.out_channels / 4),
          int(self.out_channels / 2),
          self.out_channels,
          self.out_channels,
      ]
      block = BasicBlock
      layers = [1, 2, 5, 3]
      self.inplanes = int(self.out_channels // 2)
  
      self.relu = nn.ReLU()
      if self.use_seq:
          self.maxpool3 = nn.MaxPool2D(
              kernel_size=2, stride=(2, 1), padding=(0, 1)
          )
          self.layer3 = self._make_layer(
              block, self.out_channels_block[2], layers[2], stride=1
          )
          self.conv3 = nn.Conv2D(
              self.out_channels_block[2],
              self.out_channels_block[2],
              kernel_size=3,
              stride=1,
              padding=1,
              bias_attr=False,
          )
          self.bn3 = nn.BatchNorm(self.out_channels_block[2])
  
          self.layer4 = self._make_layer(
              block, self.out_channels_block[3], layers[3], stride=1
          )
          self.conv4_1 = nn.Conv2D(
              self.out_channels_block[3],
              self.out_channels_block[3],
              kernel_size=2,
              stride=(2, 1),
              padding=(0, 1),
              bias_attr=False,
          )
          self.bn4_1 = nn.BatchNorm(self.out_channels_block[3])
          self.conv4_2 = nn.Conv2D(
              self.out_channels_block[3],
              self.out_channels_block[3],
              kernel_size=2,
              stride=1,
              padding=0,
              bias_attr=False,
          )
          self.bn4_2 = nn.BatchNorm(self.out_channels_block[3])
  
      if self.use_cnt:
          self.inplanes = int(self.out_channels // 2)
          self.v_maxpool3 = nn.MaxPool2D(
              kernel_size=2, stride=(2, 1), padding=(0, 1)
          )
          self.v_layer3 = self._make_layer(
              block, self.out_channels_block[2], layers[2], stride=1
          )
          self.v_conv3 = nn.Conv2D(
              self.out_channels_block[2],
              self.out_channels_block[2],
              kernel_size=3,
              stride=1,
              padding=1,
              bias_attr=False,
          )
          self.v_bn3 = nn.BatchNorm(self.out_channels_block[2])
  
          self.v_layer4 = self._make_layer(
              block, self.out_channels_block[3], layers[3], stride=1
          )
          self.v_conv4_1 = nn.Conv2D(
              self.out_channels_block[3],
              self.out_channels_block[3],
              kernel_size=2,
              stride=(2, 1),
              padding=(0, 1),
              bias_attr=False,
          )
          self.v_bn4_1 = nn.BatchNorm(self.out_channels_block[3])
          self.v_conv4_2 = nn.Conv2D(
              self.out_channels_block[3],
              self.out_channels_block[3],
              kernel_size=2,
              stride=1,
              padding=0,
              bias_attr=False,
          )
          self.v_bn4_2 = nn.BatchNorm(self.out_channels_block[3])
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  import paddle.nn
  from paddle.nn.initializer import TruncatedNormal, Constant, Normal, KaimingNormal
label_desc: Use image node_id 1 to create a new ResNetRFL object from inherited base classes: nn with example: obj = ResNetRFL(in_channels, out_channels, use_cnt, use_seq)