code: def __init__(
      self,
      label_list: list = None,
      load_checkpoint: str = None,
      input_ch=16,
      final_ch=180,
      width_mult=3.0,
      depth_mult=1.0,
      class_dim=1000,
      use_se=True,
      se_ratio=12,
      dropout_ratio=0.2,
      bn_momentum=0.9,
  ):
      super(ReXNetV1, self).__init__()
  
      if label_list is not None:
          self.labels = label_list
          class_dim = len(self.labels)
      else:
          label_list = []
          label_file = os.path.join(self.directory, "label_list.txt")
          files = open(label_file)
          for line in files.readlines():
              line = line.strip("\n")
              label_list.append(line)
          self.labels = label_list
          class_dim = len(self.labels)
  
      layers = [1, 2, 2, 3, 3, 5]
      strides = [1, 2, 2, 2, 1, 2]
      use_ses = [False, False, True, True, True, True]
  
      layers = [ceil(element * depth_mult) for element in layers]
      strides = sum(
          [
              [element] + [1] * (layers[idx] - 1)
              for idx, element in enumerate(strides)
          ],
          [],
      )
      if use_se:
          use_ses = sum(
              [
                  [element] * layers[idx]
                  for idx, element in enumerate(use_ses)
              ],
              [],
          )
      else:
          use_ses = [False] * sum(layers[:])
      ts = [1] * layers[0] + [6] * sum(layers[1:])
  
      self.depth = sum(layers[:]) * 3
      stem_channel = 32 / width_mult if width_mult < 1.0 else 32
      inplanes = input_ch / width_mult if width_mult < 1.0 else input_ch
  
      features = []
      in_channels_group = []
      channels_group = []
  
      # The following channel configuration is a simple instance to make each layer become an expand layer.
      for i in range(self.depth // 3):
          if i == 0:
              in_channels_group.append(
                  int(round(stem_channel * width_mult))
              )
              channels_group.append(int(round(inplanes * width_mult)))
          else:
              in_channels_group.append(
                  int(round(inplanes * width_mult))
              )
              inplanes += final_ch / (self.depth // 3 * 1.0)
              channels_group.append(int(round(inplanes * width_mult)))
  
      conv_bn_swish(
          features,
          3,
          int(round(stem_channel * width_mult)),
          kernel=3,
          stride=2,
          pad=1,
      )
  
      for block_idx, (in_c, c, t, s, se) in enumerate(
          zip(in_channels_group, channels_group, ts, strides, use_ses)
      ):
          features.append(
              LinearBottleneck(
                  in_channels=in_c,
                  channels=c,
                  t=t,
                  stride=s,
                  use_se=se,
                  se_ratio=se_ratio,
              )
          )
  
      pen_channels = int(1280 * width_mult)
      conv_bn_swish(features, c, pen_channels)
  
      features.append(nn.AdaptiveAvgPool2D(1))
      self.features = nn.Sequential(*features)
      self.output = nn.Sequential(
          nn.Dropout(dropout_ratio),
          nn.Conv2D(pen_channels, class_dim, 1, bias_attr=True),
      )
  
      if load_checkpoint is not None:
          self.model_dict = paddle.load(load_checkpoint)
          self.set_dict(self.model_dict)
          print("load custom checkpoint success")
      else:
          checkpoint = os.path.join(self.directory, "model.pdparams")
          self.model_dict = paddle.load(checkpoint)
          self.set_dict(self.model_dict)
          print("load pretrained checkpoint success")
  
imports: import os
  from math import ceil
  from typing import Union
  import paddle
  import paddle.nn
  import numpy
  import paddlehub.vision.transforms
  from paddle import ParamAttr
  from paddlehub.module.module import moduleinfo
  from paddlehub.module.cv_module import ImageClassifierModule
label_desc: Use image node_id 1 to create a new ReXNetV1 object from inherited base classes: nn with example: obj = ReXNetV1(label_list, load_checkpoint, input_ch, final_ch, width_mult, depth_mult, class_dim, use_se, se_ratio, dropout_ratio, bn_momentum)