code: def create_integer_lookup_op(
      input_arg: "relay.Expr",
      floating_point_func: Callable[[np.array], np.array],
      in_scale: "relay.Expr",
      in_zero_point: "relay.Expr",
      out_scale: "relay.Expr",
      out_zero_point: "relay.Expr",
      in_axis: int = -1,
      out_axis: int = -1,
      in_dtype: str = "uint8",
      out_dtype: str = "uint8",
  ) -> "relay.Expr":
      """
      Create a quantized version of the given floating point unary operation using table lookup.
  
      Args:
        input_arg: The quantized input to the final function.
        floating_point_func: The numpy function which this table is to approximate
        in_scale: The scale of the quantized input tensor.
        in_zero_point: The zero point of the quantized input tensor.
        out_scale: The scale of the quantized output tensor.
        out_zero_point: The zero point of the quantized output tensor.
        in_axis: The axis for multi-channel quantization of the input if applicable.
        out_axis: The axis for multi-channel quantization of the output if applicable.
        in_dtype: The dtype of the input tensor.
        out_dtype: The wanted dtype of the output tensor.
  
      Returns:
        A Relay expression representing a quantized version of the given function.
      """
  
      # TODO: handle multi-channel q, below will fail with multi-channel q
      in_scale = in_scale.data.numpy().item()
      in_zero_point = in_zero_point.data.numpy().item()
      out_scale = out_scale.data.numpy().item()
      out_zero_point = out_zero_point.data.numpy().item()
  
      lookup_table = create_integer_lookup_table(
          floating_point_func,
          relay.const(in_scale),
          relay.const(in_zero_point, dtype="int32"),
          relay.const(out_scale),
          relay.const(out_zero_point, dtype="int32"),
          in_axis=in_axis,
          in_dtype=in_dtype,
          out_axis=out_axis,
          out_dtype=out_dtype,
      )
  
      in_dtype_info = np.iinfo(in_dtype)
      in_dtype_num_bits = in_dtype_info.bits
  
      lookup_table = relay.const(lookup_table)
      index_tensor = relay.reinterpret(
          input_arg, f"uint{in_dtype_num_bits}"
      )
      result = relay.take(
          lookup_table, index_tensor, axis=0, mode="fast"
      )
      return result
  
imports: from typing import Callable
  import numpy
  import tvm
  from tvm import relay
label_desc: Use image node_id 3 for calling a global function with example usage: create_integer_lookup_op(input_arg, floating_point_func, in_scale, in_zero_point, out_scale, out_zero_point, in_axis, out_axis, in_dtype, out_dtype) and returns: result