code: def _convert_advanced_activation(
      inexpr, keras_layer, etab, data_layout, input_shape=None
  ):
      act_type = type(keras_layer).__name__
      if input_shape is None:
          input_shape = keras_layer.input_shape
  
      if act_type == "Softmax":
          axis = keras_layer.axis
          dims = len(input_shape) if input_shape else 0
          if isinstance(axis, list):
              raise tvm.error.OpAttributeUnImplemented(
                  f"Softmax with axes {axis} is not supported."
              )
          if data_layout == "NCHW":
              if dims == 0:
                  axis = 0
              elif axis == -1:
                  axis = 1
              else:
                  axis = axis + 1 if axis < dims - 1 else 1
          return _op.nn.softmax(inexpr, axis=axis)
      if act_type == "ReLU":
          if np.isnan(keras_layer.threshold).any():
              raise tvm.error.OpAttributeInvalid(
                  "The threshold value of a ReLU cannot be None."
              )
          threshold = _expr.const(
              keras_layer.threshold, dtype="float32"
          )
          if (
              keras_layer.max_value
              and float(keras_layer.threshold) == 0
          ):
              # f(x) = max_value, for x >= max_value
              # f(x) = x,         for threshold <= x < max_value
              return _op.clip(
                  inexpr, a_min=0.0, a_max=float(keras_layer.max_value)
              )
          if keras_layer.max_value and _op.greater(
              threshold, inexpr
          ).astype("float32"):
              # f(x) = negative_slope * (inexpr - threshold)
              negative_slope = _expr.const(
                  keras_layer.negative_slope, dtype="float32"
              )
              return _op.multiply(
                  negative_slope, _op.subtract(inexpr, threshold)
              )
          return _op.nn.relu(inexpr)
      if act_type == "LeakyReLU":
          if np.isnan(keras_layer.alpha).any():
              raise tvm.error.OpAttributeInvalid(
                  "The alpha value of a LeakyReLU cannot be None."
              )
          return _op.nn.leaky_relu(
              inexpr, alpha=float(keras_layer.alpha)
          )
      if act_type == "ELU":
          if np.isnan(keras_layer.alpha).any():
              raise tvm.error.OpAttributeInvalid(
                  "The alpha value of a ELU cannot be None."
              )
          alpha = (
              keras_layer.alpha
              if hasattr(keras_layer, "alpha")
              else 1.0
          )
          alpha = _expr.const(alpha, dtype="float32")
          return _get_elu(inexpr, alpha)
      if act_type == "PReLU":
          assert hasattr(
              keras_layer, "alpha"
          ), "alpha required for PReLU."
          _check_data_format(keras_layer)
          size = len(keras_layer.alpha.shape)
          if data_layout == "NCHW":
              alpha = etab.new_const(
                  keras_layer.get_weights()[0].transpose(
                      np.roll(range(size), 1)
                  )
              )
          else:
              alpha = etab.new_const(keras_layer.get_weights()[0])
          return _op.negative(alpha) * _op.nn.relu(
              _op.negative(inexpr)
          ) + _op.nn.relu(inexpr)
      if act_type == "ThresholdedReLU":
          theta = (
              keras_layer.theta
              if hasattr(keras_layer, "theta")
              else 1.0
          )
          return _op.multiply(
              inexpr,
              _op.greater(
                  inexpr, _expr.const(theta, dtype="float32")
              ).astype("float32"),
          )
  
      raise tvm.error.OpNotImplemented(
          f"Operator {act_type} is not supported in frontend Keras."
      )
  
imports: import dis
  import sys
  import numpy
  import tvm
  from tvm.ir import IRModule, TensorType, TupleType
  from ..None import analysis
  from ..None import expr
  from ..None import function
  from ..None import op
  from ...None import nd
  from .common import ExprTable, new_var
label_desc: Use image node_id 7 for calling a global function with example usage: _convert_advanced_activation(inexpr, keras_layer, etab, data_layout, input_shape) and returns: _op, _op, _op, _get_elu, unknown, _op, _op, _op