code: def __init__(
      self,
      n_class=1000,
      input_size=224,
      width_mult=1.0,
      activation="relu6",
  ):
      super(MobileNetV2, self).__init__()
  
      activation_block = get_activation_block(activation)
  
      block = InvertedResidual
      input_channel = 32
      last_channel = 1280
      interverted_residual_setting = [
          # t, c, n, s
          [1, 16, 1, 1],
          [6, 24, 2, 2],
          [6, 32, 3, 2],
          [6, 64, 4, 2],
          [6, 96, 3, 1],
          [6, 160, 3, 2],
          [6, 320, 1, 1],
      ]
  
      # building first layer
      assert input_size % 32 == 0
      input_channel = int(input_channel * width_mult)
      self.last_channel = (
          int(last_channel * width_mult)
          if width_mult > 1.0
          else last_channel
      )
      self.layer0 = conv_bn(3, input_channel, 2, activation_block)
  
      # building inverted residual blocks
      for layer_index, (t, c, n, s) in enumerate(
          interverted_residual_setting
      ):
          output_channel = int(c * width_mult)
  
          blocks = []
          for i in range(n):
              if i == 0:
                  blocks.append(
                      block(
                          input_channel,
                          output_channel,
                          s,
                          expand_ratio=t,
                          activation=activation_block,
                      )
                  )
              else:
                  blocks.append(
                      block(
                          input_channel,
                          output_channel,
                          1,
                          expand_ratio=t,
                          activation=activation_block,
                      )
                  )
  
              input_channel = output_channel
  
          self.add_module(
              f"layer{layer_index + 1}", nn.Sequential(*blocks)
          )
  
      # building last several layers
      self.final_layer = conv_1x1_bn(
          input_channel, self.last_channel, activation=activation_block
      )
  
      # building classifier
      self.classifier = nn.Sequential(
          nn.Dropout(0.2), nn.Linear(self.last_channel, n_class)
      )
  
      self._initialize_weights()
  
file_path: pytorch-toolbelt/pytorch_toolbelt/modules/backbone/mobilenet.py
imports: from __future__ import absolute_import
  import math
  import torch.nn
  from ..activations import get_activation_block
label_desc: Use image node_id 1 to create a new MobileNetV2 object from inherited base classes: nn with example: obj = MobileNetV2(n_class, input_size, width_mult, activation)