Revert "[QNN] Concatenate operator (#3730)"

This reverts commit f06ef4f.

python/tvm/relay/qnn/op/qnn.py

@@ -18,7 +18,6 @@
 """QNN dialect operators."""
 
 from __future__ import absolute_import as _abs
-from tvm import relay
 from . import _make
 
 def requantize(data,
@@ -73,75 +72,3 @@ def requantize(data,
                             output_zero_point,
                             rounding,
                             out_dtype)
-
-def concatenate(data,
-                input_scales,
-                input_zero_points,
-                output_scale,
-                output_zero_point,
-                axis):
-    """Concatenate the quantized input tensors along the given axis.
-
-    Parameters
-    ----------
-    data : Union(List[relay.Expr], Tuple[relay.Expr])
-        The list of quantized tensors.
-
-    input_scales : List[float32]
-        The list of scales of input quantized tensors.
-
-    input_zero_points : List[int32]
-        The list of zero points of input quantized tensors.
-
-    output_scale : float32
-        The scale of the output quantized tensor.
-
-    output_zero_point : int32
-        The zero point of the output quantized tensor.
-
-    axis : int
-        The axis along which the tensors are concatenated.
-
-    Returns
-    -------
-    result: relay.Expr
-        The concatenated quantized tensor.
-    """
-
-    data = list(data)
-    requantized_exprs = list(data)
-
-    # Find the dtype of the input expr. This is required for the requantize op. Since, this is
-    # concatenate op, the dtype of the input is same as dtype of the output.
-    data0 = relay.transform.infer_type(data[0])
-    in_dtype = data0.checked_type.dtype
-
-    # First check if all the input qnn params match. If yes, we can call concatenate first, followed
-    # by a requantize.
-    if all(scale == input_scales[0] for scale in input_scales)\
-            and all(zero_point == input_zero_points[0] for zero_point in input_zero_points):
-        out = relay.concatenate(tuple(data), axis)
-        input_scale = input_scales[0]
-        input_zero_point = input_zero_points[0]
-        if input_scale != output_scale or input_zero_point != output_zero_point:
-            out = requantize(data=out,
-                             input_scale=input_scales[0],
-                             input_zero_point=input_zero_points[0],
-                             output_scale=output_scale,
-                             output_zero_point=output_zero_point,
-                             out_dtype=in_dtype)
-        return out
-
-    # If the output qnn params do not match the input qnn params, we can call requantize on the
-    # input expr first, followed by a concatenate on the requantized input exprs.
-    for idx, quantized_expr in enumerate(data):
-        input_scale = input_scales[idx]
-        input_zero_point = input_zero_points[idx]
-        if input_scale != output_scale or input_zero_point != output_zero_point:
-            requantized_exprs[idx] = requantize(data=quantized_expr,
-                                                input_scale=input_scale,
-                                                input_zero_point=input_zero_point,
-                                                output_scale=output_scale,
-                                                output_zero_point=output_zero_point,
-                                                out_dtype=in_dtype)
-    return relay.concatenate(tuple(requantized_exprs), axis)