code: def __init__(
      self,
      in_planes,
      out_planes,
      block_num=3,
      stride=1,
      relative_lr=1.0,
  ):
      super(CatBottleneck, self).__init__()
      assert block_num > 1, "block number should be larger than 1."
      self.conv_list = nn.LayerList()
      self.stride = stride
      param_attr = paddle.ParamAttr(learning_rate=relative_lr)
      if stride == 2:
          self.avd_layer = nn.Sequential(
              nn.Conv2D(
                  out_planes // 2,
                  out_planes // 2,
                  kernel_size=3,
                  stride=2,
                  padding=1,
                  groups=out_planes // 2,
                  weight_attr=param_attr,
                  bias_attr=False,
              ),
              nn.BatchNorm2D(
                  out_planes // 2,
                  weight_attr=param_attr,
                  bias_attr=param_attr,
              ),
          )
          self.skip = nn.AvgPool2D(kernel_size=3, stride=2, padding=1)
          stride = 1
  
      for idx in range(block_num):
          if idx == 0:
              self.conv_list.append(
                  ConvBNRelu(
                      in_planes,
                      out_planes // 2,
                      kernel=1,
                      relative_lr=relative_lr,
                  )
              )
          elif idx == 1 and block_num == 2:
              self.conv_list.append(
                  ConvBNRelu(
                      out_planes // 2,
                      out_planes // 2,
                      stride=stride,
                      relative_lr=relative_lr,
                  )
              )
          elif idx == 1 and block_num > 2:
              self.conv_list.append(
                  ConvBNRelu(
                      out_planes // 2,
                      out_planes // 4,
                      stride=stride,
                      relative_lr=relative_lr,
                  )
              )
          elif idx < block_num - 1:
              self.conv_list.append(
                  ConvBNRelu(
                      out_planes // int(math.pow(2, idx)),
                      out_planes // int(math.pow(2, idx + 1)),
                      relative_lr=relative_lr,
                  )
              )
          else:
              self.conv_list.append(
                  ConvBNRelu(
                      out_planes // int(math.pow(2, idx)),
                      out_planes // int(math.pow(2, idx)),
                      relative_lr=relative_lr,
                  )
              )
  
imports: import math
  import paddle
  import paddle.nn
  from paddleseg.utils import utils
  from paddleseg.cvlibs import manager, param_init
  from paddleseg.models.layers.layer_libs import SyncBatchNorm
label_desc: Use image node_id 1 to create a new CatBottleneck object from inherited base classes: nn with example: obj = CatBottleneck(in_planes, out_planes, block_num, stride, relative_lr)