code: def split_separable_conv2d(
      input_tensor,
      num_outputs,
      scope=None,
      normalizer_fn=None,
      stride=1,
      rate=1,
      endpoints=None,
      use_explicit_padding=False,
  ):
      """Separable mobilenet V1 style convolution.
  
      Depthwise convolution, with default non-linearity,
      followed by 1x1 depthwise convolution.  This is similar to
      slim.separable_conv2d, but differs in tha it applies batch
      normalization and non-linearity to depthwise. This  matches
      the basic building of Mobilenet Paper
      (https://arxiv.org/abs/1704.04861)
  
      Args:
        input_tensor: input
        num_outputs: number of outputs
        scope: optional name of the scope. Note if provided it will use
        scope_depthwise for deptwhise, and scope_pointwise for pointwise.
        normalizer_fn: which normalizer function to use for depthwise/pointwise
        stride: stride
        rate: output rate (also known as dilation rate)
        endpoints: optional, if provided, will export additional tensors to it.
        use_explicit_padding: Use 'VALID' padding for convolutions, but prepad
          inputs so that the output dimensions are the same as if 'SAME' padding
          were used.
  
      Returns:
        output tesnor
      """
  
      with _v1_compatible_scope_naming(scope) as scope:
          dw_scope = scope + "depthwise"
          endpoints = endpoints if endpoints is not None else {}
          kernel_size = [3, 3]
          padding = "SAME"
          if use_explicit_padding:
              padding = "VALID"
              input_tensor = _fixed_padding(
                  input_tensor, kernel_size, rate
              )
          net = slim.separable_conv2d(
              input_tensor,
              None,
              kernel_size,
              depth_multiplier=1,
              stride=stride,
              rate=rate,
              normalizer_fn=normalizer_fn,
              padding=padding,
              scope=dw_scope,
          )
  
          endpoints[dw_scope] = net
  
          pw_scope = scope + "pointwise"
          net = slim.conv2d(
              net,
              num_outputs,
              [1, 1],
              stride=1,
              normalizer_fn=normalizer_fn,
              scope=pw_scope,
          )
          endpoints[pw_scope] = net
      return net
  
file_path: MMdnn/mmdnn/conversion/examples/tensorflow/models/mobilenet/conv_blocks.py
imports: import contextlib
  import functools
  import tensorflow
label_desc: Use image node_id 5 for calling a global function with example usage: split_separable_conv2d(input_tensor, num_outputs, scope, normalizer_fn, stride, rate, endpoints, use_explicit_padding) and returns: net