code: def __init__(
      self,
      builder: LayerBuilder,
      depsep_kernel_size: int,
      in_channels: int,
      out_channels: int,
      expand_ratio: int,
      stride: int,
      squeeze_excitation_ratio: float,
      squeeze_hidden=False,
      survival_prob: float = 1.0,
      quantized: bool = False,
      trt: bool = False,
  ):
      super().__init__()
      self.quantized = quantized
      self.residual = stride == 1 and in_channels == out_channels
      hidden_dim = in_channels * expand_ratio
      squeeze_base = hidden_dim if squeeze_hidden else in_channels
      squeeze_dim = max(1, int(squeeze_base * squeeze_excitation_ratio))
  
      self.expand = (
          None
          if in_channels == hidden_dim
          else builder.conv1x1(
              in_channels, hidden_dim, bn=True, act=True
          )
      )
      self.depsep = builder.convDepSep(
          depsep_kernel_size,
          hidden_dim,
          hidden_dim,
          stride,
          bn=True,
          act=True,
      )
      if trt or self.quantized:
          # Need TRT mode for quantized in order to automatically insert quantization before pooling
          self.se: nn.Module = SequentialSqueezeAndExcitationTRT(
              hidden_dim,
              squeeze_dim,
              builder.activation(),
              self.quantized,
          )
      else:
          self.se: nn.Module = SequentialSqueezeAndExcitation(
              hidden_dim,
              squeeze_dim,
              builder.activation(),
              self.quantized,
          )
  
      self.proj = builder.conv1x1(hidden_dim, out_channels, bn=True)
  
      if survival_prob == 1.0:
          self.residual_add = torch.add
      else:
          self.residual_add = StochasticDepthResidual(
              survival_prob=survival_prob
          )
      if self.quantized and self.residual:
          assert (
              quant_nn is not None
          ), "pytorch_quantization is not available"
          self.residual_quantizer = quant_nn.TensorQuantizer(
              quant_nn.QuantConv2d.default_quant_desc_input
          )  # TODO QuantConv2d ?!?
      else:
          self.residual_quantizer = nn.Identity()
  
imports: import argparse
  import random
  import math
  import warnings
  from typing import List, Any, Optional
  from collections import namedtuple, OrderedDict
  from dataclasses import dataclass, replace
  import torch
  from torch import nn
  from functools import partial
  from .common import SequentialSqueezeAndExcitation, SequentialSqueezeAndExcitationTRT, LayerBuilder, StochasticDepthResidual, Flatten
  from .model import Model, ModelParams, ModelArch, OptimizerParams, create_entrypoint, EntryPoint
label_desc: Use image node_id 1 to create a new MBConvBlock object from inherited base classes: nn with example: obj = MBConvBlock(builder, depsep_kernel_size, in_channels, out_channels, expand_ratio, stride, squeeze_excitation_ratio, squeeze_hidden, survival_prob, quantized, trt)