class_docstr: A class of MBConv: Mobile Inverted Residual Bottleneck.
  
  Attributes:
    endpoints: dict. A list of internal tensors.
class_docstr_tok: ["A","class","of","MBConv",":","Mobile","Inverted","Residual","Bottleneck",".","Attributes",":","endpoints",":","dict",".","A","list","of","internal","tensors","."]
docstr: Implementation of call().
  
  Args:
    inputs: the inputs tensor.
    training: boolean, whether the model is constructed for training.
    survival_prob: float, between 0 to 1, drop connect rate.
  
  Returns:
    A output tensor.
docstr_tok: ["Implementation","of","call","(",")",".","Args",":","inputs",":","the","inputs","tensor",".","training",":","boolean",",","whether","the","model","is","constructed","for","training",".","survival_prob",":","float",",","between","0","to","1",",","drop","connect","rate",".","Returns",":","A","output","tensor","."]
code: def call(self, inputs, training=True, survival_prob=None):
      """Implementation of call().
  
      Args:
        inputs: the inputs tensor.
        training: boolean, whether the model is constructed for training.
        survival_prob: float, between 0 to 1, drop connect rate.
  
      Returns:
        A output tensor.
      """
      logging.info(
          "Block input: %s shape: %s", inputs.name, inputs.shape
      )
      logging.info(
          "Block input depth: %s output depth: %s",
          self._block_args.input_filters,
          self._block_args.output_filters,
      )
  
      x = inputs
  
      fused_conv_fn = self._fused_conv
      expand_conv_fn = self._expand_conv
      depthwise_conv_fn = self._depthwise_conv
      project_conv_fn = self._project_conv
  
      if self._block_args.condconv:
          pooled_inputs = self._avg_pooling(inputs)
          routing_weights = self._routing_fn(pooled_inputs)
          # Capture routing weights as additional input to CondConv layers
          fused_conv_fn = functools.partial(
              self._fused_conv, routing_weights=routing_weights
          )
          expand_conv_fn = functools.partial(
              self._expand_conv, routing_weights=routing_weights
          )
          depthwise_conv_fn = functools.partial(
              self._depthwise_conv, routing_weights=routing_weights
          )
          project_conv_fn = functools.partial(
              self._project_conv, routing_weights=routing_weights
          )
  
      # creates conv 2x2 kernel
      if self._block_args.super_pixel == 1:
          with tf.variable_scope("super_pixel"):
              x = self._relu_fn(
                  self._bnsp(self._superpixel(x), training=training)
              )
          logging.info(
              "Block start with SuperPixel: %s shape: %s",
              x.name,
              x.shape,
          )
  
      if self._block_args.fused_conv:
          # If use fused mbconv, skip expansion and use regular conv.
          x = self._relu_fn(
              self._bn1(fused_conv_fn(x), training=training)
          )
          logging.info("Conv2D: %s shape: %s", x.name, x.shape)
      else:
          # Otherwise, first apply expansion and then apply depthwise conv.
          if self._block_args.expand_ratio != 1:
              x = self._relu_fn(
                  self._bn0(expand_conv_fn(x), training=training)
              )
              logging.info("Expand: %s shape: %s", x.name, x.shape)
  
          x = self._relu_fn(
              self._bn1(depthwise_conv_fn(x), training=training)
          )
          logging.info("DWConv: %s shape: %s", x.name, x.shape)
  
      if self._has_se:
          with tf.variable_scope("se"):
              x = self._call_se(x)
  
      self.endpoints = {"expansion_output": x}
  
      x = self._bn2(project_conv_fn(x), training=training)
      # Add identity so that quantization-aware training can insert quantization
      # ops correctly.
      x = tf.identity(x)
      if self._clip_projection_output:
          x = tf.clip_by_value(x, -6, 6)
      if self._block_args.id_skip:
          if (
              all(s == 1 for s in self._block_args.strides)
              and self._block_args.input_filters
              == self._block_args.output_filters
          ):
              # Apply only if skip connection presents.
              if survival_prob:
                  x = utils.drop_connect(x, training, survival_prob)
              x = tf.add(x, inputs)
      logging.info("Project: %s shape: %s", x.name, x.shape)
      return x
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import collections
  import functools
  import math
  from absl import logging
  import numpy
  import six
  from six.moves import xrange
  import tensorflow.compat.v1
  import utils
label_desc: Use image node_id 5 for calling the MBConvBlock obj's underlying member method code with example usage: obj.call(inputs, training, survival_prob) and returns: x