class_docstr: MNASNet, as described in https://arxiv.org/pdf/1807.11626.pdf. This
  implements the B1 variant of the model.
  >>> model = MNASNet(1000, 1.0)
  >>> x = torch.rand(1, 3, 224, 224)
  >>> y = model(x)
  >>> y.dim()
  1
  >>> y.nelement()
  1000
code: def __init__(
      self,
      alpha,
      depths,
      convops,
      kernel_sizes,
      num_layers,
      skips,
      num_classes=1000,
      dropout=0.2,
  ):
      super().__init__()
      assert alpha > 0.0
      assert (
          len(depths)
          == len(convops)
          == len(kernel_sizes)
          == len(num_layers)
          == len(skips)
          == 7
      )
      self.alpha = alpha
      self.num_classes = num_classes
      depths = _get_depths([_FIRST_DEPTH] + depths, alpha)
      base_filter_sizes = [16, 24, 40, 80, 96, 192, 320]
      exp_ratios = [3, 3, 3, 6, 6, 6, 6]
      strides = [1, 2, 2, 2, 1, 2, 1]
      layers = [
          # First layer: regular conv.
          nn.Conv2d(3, depths[0], 3, padding=1, stride=2, bias=False),
          nn.BatchNorm2d(depths[0], momentum=_BN_MOMENTUM),
          nn.ReLU(inplace=True),
      ]
      count = 0
      # for conv, prev_depth, depth, ks, skip, stride, repeat, exp_ratio in \
      #        zip(convops, depths[:-1], depths[1:], kernel_sizes, skips, strides, num_layers, exp_ratios):
      for filter_size, exp_ratio, stride in zip(
          base_filter_sizes, exp_ratios, strides
      ):
          # TODO: restrict that "choose" can only be used within mutator
          ph = nn.Placeholder(
              label=f"mutable_{count}",
              **{
                  "kernel_size_options": [1, 3, 5],
                  "n_layer_options": [1, 2, 3, 4],
                  "op_type_options": [
                      "__mutated__.base_mnasnet.RegularConv",
                      "__mutated__.base_mnasnet.DepthwiseConv",
                      "__mutated__.base_mnasnet.MobileConv",
                  ],
                  # 'se_ratio_options': [0, 0.25],
                  "skip_options": ["identity", "no"],
                  "n_filter_options": [
                      int(filter_size * x) for x in [0.75, 1.0, 1.25]
                  ],
                  "exp_ratio": exp_ratio,
                  "stride": stride,
                  "in_ch": depths[0] if count == 0 else None,
              },
          )
          layers.append(ph)
          """if conv == "mconv":
                  # MNASNet blocks: stacks of inverted residuals.
                  layers.append(_stack_inverted_residual(prev_depth, depth, ks, skip,
                                                         stride, exp_ratio, repeat, _BN_MOMENTUM))
              else:
                  # Normal conv and depth-separated conv
                  layers += _stack_normal_conv(prev_depth, depth, ks, skip, conv == "dconv",
                                               stride, repeat, _BN_MOMENTUM)"""
          count += 1
          if count >= 2:
              break
      layers += [
          # Final mapping to classifier input.
          nn.Conv2d(
              depths[7], 1280, 1, padding=0, stride=1, bias=False
          ),
          nn.BatchNorm2d(1280, momentum=_BN_MOMENTUM),
          nn.ReLU(inplace=True),
      ]
      self.layers = nn.Sequential(*layers)
      self.classifier = nn.Sequential(
          nn.Dropout(p=dropout), nn.Linear(1280, num_classes)
      )
      self._initialize_weights()
  
imports: from nni.retiarii import basic_unit
  import nni.retiarii.nn.pytorch
  import warnings
  import torch
  import torch.nn
  import torch.nn.functional
  from nni.retiarii import model_wrapper
  import sys
  from pathlib import Path
label_desc: Use image node_id 1 to create a new MNASNet object from inherited base classes: nn with example: obj = MNASNet(alpha, depths, convops, kernel_sizes, num_layers, skips, num_classes, dropout)