code: def __init__(
      self,
      inp,
      output,
      kernel_size,
      depth_multiplier=1,
      with_bn=True,
      **kwargs,
  ):
      super(SepCONV, self).__init__(**kwargs)
      with self.name_scope():
          self.net = nn.HybridSequential()
          cn = int(inp * depth_multiplier)
  
          if output is None:
              self.net.add(
                  nn.Conv2D(
                      in_channels=inp,
                      channels=cn,
                      groups=inp,
                      kernel_size=kernel_size,
                      strides=(1, 1),
                      padding=kernel_size // 2,
                      use_bias=not with_bn,
                  )
              )
          else:
              self.net.add(
                  nn.Conv2D(
                      in_channels=inp,
                      channels=cn,
                      groups=inp,
                      kernel_size=kernel_size,
                      strides=(1, 1),
                      padding=kernel_size // 2,
                      use_bias=False,
                  ),
                  nn.BatchNorm(),
                  Act(),
                  # nn.Activation('relu'),
                  nn.Conv2D(
                      in_channels=cn,
                      channels=output,
                      kernel_size=(1, 1),
                      strides=(1, 1),
                      use_bias=not with_bn,
                  ),
              )
  
          self.with_bn = with_bn
          self.act = Act()
          # self.act = nn.Activation('relu')
          if with_bn:
              self.bn = nn.BatchNorm()
  
imports: import sys
  import os
  import mxnet
  import mxnet.ndarray
  import mxnet.gluon
  import mxnet.gluon.nn
  import mxnet.autograd
  import symbol_utils
  from config import config
label_desc: Use image node_id 1 to create a new SepCONV object from inherited base classes: nn with example: obj = SepCONV(inp, output, kernel_size, depth_multiplier, with_bn)