code: def __init__(self, num_classes=1000, alpha=1.0, round_nearest=8):
      super(MobileNetV2, self).__init__()
      block = InvertedResidual
      input_channel = _make_divisible(32 * alpha, round_nearest)
      last_channel = _make_divisible(1280 * alpha, round_nearest)
  
      inverted_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],
      ]
  
      features = []
      # conv1 layer
      features.append(ConvBNReLU(3, input_channel, stride=2))
      # building inverted residual residual blockes
      for t, c, n, s in inverted_residual_setting:
          output_channel = _make_divisible(c * alpha, round_nearest)
          for i in range(n):
              stride = s if i == 0 else 1
              features.append(
                  block(
                      input_channel,
                      output_channel,
                      stride,
                      expand_ratio=t,
                  )
              )
              input_channel = output_channel
      # building last several layers
      features.append(ConvBNReLU(input_channel, last_channel, 1))
      # combine feature layers
      self.features = nn.Sequential(*features)
  
      # building classifier
      self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
      self.classifier = nn.Sequential(
          nn.Dropout(0.2), nn.Linear(last_channel, num_classes)
      )
  
      # weight initialization
      for m in self.modules():
          if isinstance(m, nn.Conv2d):
              nn.init.kaiming_normal_(m.weight, mode="fan_out")
              if m.bias is not None:
                  nn.init.zeros_(m.bias)
          elif isinstance(m, nn.BatchNorm2d):
              nn.init.ones_(m.weight)
              nn.init.zeros_(m.bias)
          elif isinstance(m, nn.Linear):
              nn.init.normal_(m.weight, 0, 0.01)
              nn.init.zeros_(m.bias)
  
file_path: deep-learning-for-image-processing/pytorch_classification/Test6_mobilenet/model_v2.py
imports: from torch import nn
  import torch
label_desc: Use image node_id 1 to create a new MobileNetV2 object from inherited base classes: nn with example: obj = MobileNetV2(num_classes, alpha, round_nearest)