replace trt_version in tensorrt/impls (PaddlePaddle#75826)

* update python/paddle/tensorrt/impls to support tensorrt 10

* fix

Author: co63oc

python/paddle/tensorrt/impls/activation.py

@@ -298,8 +298,8 @@ def hardswish_converter(network, paddle_op, inputs):
     return hardswish_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.elu", trt_version="8.x")
-@converter_registry.register("pd_op.elu_", trt_version="8.x")
+@converter_registry.register("pd_op.elu")
+@converter_registry.register("pd_op.elu_")
 def elu_converter(network, paddle_op, inputs):
     x = inputs[0]
     alpha = paddle_op.attrs()["alpha"]
@@ -309,7 +309,7 @@ def elu_converter(network, paddle_op, inputs):
     return elu_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.softplus", trt_version="8.x")
+@converter_registry.register("pd_op.softplus")
 def softplus_converter(network, paddle_op, inputs):
     x = inputs[0]
     beta = paddle_op.attrs()["beta"]
@@ -328,8 +328,8 @@ def softplus_converter(network, paddle_op, inputs):
     return softplus_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.swish", trt_version="8.x")
-@converter_registry.register("pd_op.silu", trt_version="8.x")
+@converter_registry.register("pd_op.swish")
+@converter_registry.register("pd_op.silu")
 def swish_silu_converter(network, paddle_op, inputs):
     layer_output = network.add_activation(
         inputs[0], activation_type_map[paddle_op.name()]
@@ -343,7 +343,7 @@ def swish_silu_converter(network, paddle_op, inputs):
     )
 
 
-@converter_registry.register("pd_op.tanh_shrink", trt_version="8.x")
+@converter_registry.register("pd_op.tanh_shrink")
 def tanh_shrink_converter(network, paddle_op, inputs):
     x = inputs[0]
     tanh_layer = network.add_activation(x, trt.ActivationType.TANH)
@@ -355,7 +355,7 @@ def tanh_shrink_converter(network, paddle_op, inputs):
     return subtract_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.stanh", trt_version="8.x")
+@converter_registry.register("pd_op.stanh")
 def stanh_converter(network, paddle_op, inputs):
     x = inputs[0]
     scale_a = paddle_op.attrs()["scale_a"]
@@ -367,7 +367,7 @@ def stanh_converter(network, paddle_op, inputs):
     return stanh_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.mish", trt_version="8.x")
+@converter_registry.register("pd_op.mish")
 def mish_converter(network, paddle_op, inputs):
     x = inputs[0]
     softplus_layer = network.add_activation(x, trt.ActivationType.SOFTPLUS)
@@ -385,7 +385,7 @@ def mish_converter(network, paddle_op, inputs):
     )
 
 
-@converter_registry.register("pd_op.celu", trt_version="8.x")
+@converter_registry.register("pd_op.celu")
 def celu_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     alpha = paddle_op.attrs()["alpha"]
@@ -451,7 +451,7 @@ def celu_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.thresholded_relu", trt_version="8.x")
+@converter_registry.register("pd_op.thresholded_relu")
 def thresholded_relu_converter(network, paddle_op, inputs):
     x = inputs[0]
     threshold = paddle_op.attrs()["threshold"]
@@ -463,8 +463,8 @@ def thresholded_relu_converter(network, paddle_op, inputs):
     return thresholded_relu_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.leaky_relu", trt_version="8.x")
-@converter_registry.register("pd_op.leaky_relu_", trt_version="8.x")
+@converter_registry.register("pd_op.leaky_relu")
+@converter_registry.register("pd_op.leaky_relu_")
 def leaky_relu_converter(network, paddle_op, inputs):
     x = inputs[0]
     negative_slope = paddle_op.attrs()["negative_slope"]
@@ -474,7 +474,7 @@ def leaky_relu_converter(network, paddle_op, inputs):
     return leaky_relu_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.selu", trt_version="8.x")
+@converter_registry.register("pd_op.selu")
 def selu_converter(network, paddle_op, inputs):
     x = inputs[0]
     alpha = paddle_op.attrs()["alpha"]
@@ -486,7 +486,7 @@ def selu_converter(network, paddle_op, inputs):
     return selu_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.prelu", trt_version="8.x")
+@converter_registry.register("pd_op.prelu")
 def prelu_converter(network, paddle_op, inputs):
     input, alpha_data = inputs
     input_dims = input.shape

python/paddle/tensorrt/impls/common.py

@@ -30,7 +30,7 @@
 from paddle.tensorrt.util import get_trt_version_list
 
 
-@converter_registry.register("pd_op.dropout", trt_version="8.x")
+@converter_registry.register("pd_op.dropout")
 def dropout_converter(network, paddle_op, inputs):
     input_x = inputs[0]
     dropout_prob = get_input_constant_value(paddle_op, inputs, 2)[0]

python/paddle/tensorrt/impls/creation.py

@@ -65,17 +65,17 @@ def full_converter(network, paddle_op, inputs):
     return full_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.assign", trt_version="8.x")
-@converter_registry.register("pd_op.assign_out_", trt_version="8.x")
+@converter_registry.register("pd_op.assign")
+@converter_registry.register("pd_op.assign_out_")
 def assign_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     identity_layer = network.add_identity(input_tensor)
     set_layer_name(identity_layer, paddle_op)
     return identity_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.assign_value", trt_version="8.x")
-@converter_registry.register("pd_op.assign_value_", trt_version="8.x")
+@converter_registry.register("pd_op.assign_value")
+@converter_registry.register("pd_op.assign_value_")
 def assign_value_converter(network, paddle_op, inputs):
     attrs = paddle_op.attrs()
     shape = attrs['shape']
@@ -108,7 +108,7 @@ def assign_value_converter(network, paddle_op, inputs):
     return const_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.arange", trt_version="8.x")
+@converter_registry.register("pd_op.arange")
 def arange_converter(network, paddle_op, inputs):
     start, end, step = inputs
     zero_tensor = add_1D_constant_layer(
@@ -163,7 +163,7 @@ def arange_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.full_like", trt_version="8.x")
+@converter_registry.register("pd_op.full_like")
 def full_like_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     shape = input_tensor.shape
@@ -273,7 +273,7 @@ def full_like_converter(network, paddle_op, inputs):
     return output
 
 
-@converter_registry.register("pd_op.full_with_tensor", trt_version="8.x")
+@converter_registry.register("pd_op.full_with_tensor")
 def full_with_tensor_converter(network, paddle_op, inputs):
     value_input = inputs[0]
 
@@ -373,7 +373,7 @@ def full_with_tensor_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.meshgrid", trt_version="8.x")
+@converter_registry.register("pd_op.meshgrid")
 def meshgrid_converter(network, paddle_op, vec_inputs):
     inputs = vec_inputs[0]
     n = len(inputs)

python/paddle/tensorrt/impls/einsum.py

@@ -17,7 +17,7 @@
 from paddle.tensorrt.register import converter_registry
 
 
-@converter_registry.register("pd_op.einsum", trt_version="8.x")
+@converter_registry.register("pd_op.einsum")
 def convert_einsum(network, paddle_op, inputs):
     equation = paddle_op.attrs().get("equation", "")
 

python/paddle/tensorrt/impls/logic.py

@@ -35,23 +35,23 @@
 }
 
 
-@converter_registry.register("pd_op.greater_than", trt_version="8.x")
-@converter_registry.register("pd_op.less_than", trt_version="8.x")
-@converter_registry.register("pd_op.equal", trt_version="8.x")
-@converter_registry.register("pd_op.bitwise_and", trt_version="8.x")
-@converter_registry.register("pd_op.bitwise_or", trt_version="8.x")
-@converter_registry.register("pd_op.logical_xor", trt_version="8.x")
-@converter_registry.register("pd_op.logical_or", trt_version="8.x")
-@converter_registry.register("pd_op.logical_or_", trt_version="8.x")
-@converter_registry.register("pd_op.logical_and", trt_version="8.x")
+@converter_registry.register("pd_op.greater_than")
+@converter_registry.register("pd_op.less_than")
+@converter_registry.register("pd_op.equal")
+@converter_registry.register("pd_op.bitwise_and")
+@converter_registry.register("pd_op.bitwise_or")
+@converter_registry.register("pd_op.logical_xor")
+@converter_registry.register("pd_op.logical_or")
+@converter_registry.register("pd_op.logical_or_")
+@converter_registry.register("pd_op.logical_and")
 def logic_converter(network, paddle_op, inputs):
     layer_output = add_elementwise_layer(
         network, paddle_op, inputs, logic_type_map[paddle_op.name()]
     )
     return layer_output
 
 
-@converter_registry.register("pd_op.not_equal", trt_version="8.x")
+@converter_registry.register("pd_op.not_equal")
 def not_equal_converter(network, paddle_op, inputs):
     layer_output = add_elementwise_layer(
         network, paddle_op, inputs, trt.ElementWiseOperation.EQUAL
@@ -62,7 +62,7 @@ def not_equal_converter(network, paddle_op, inputs):
     return layer_output
 
 
-@converter_registry.register("pd_op.bitwise_not", trt_version="8.x")
+@converter_registry.register("pd_op.bitwise_not")
 def bitwise_not_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     if input_tensor.dtype == trt.bool:
@@ -93,8 +93,8 @@ def bitwise_not_converter(network, paddle_op, inputs):
     return layer_output
 
 
-@converter_registry.register("pd_op.logical_not", trt_version="8.x")
-@converter_registry.register("pd_op.logical_not_", trt_version="8.x")
+@converter_registry.register("pd_op.logical_not")
+@converter_registry.register("pd_op.logical_not_")
 def logic_not_converter(network, paddle_op, inputs):
     layer_output = unary_op_converter(network, paddle_op, inputs)
     return layer_output

python/paddle/tensorrt/impls/manipulation.py

@@ -84,7 +84,7 @@ def reshape_converter(network, paddle_op, inputs):
     return layer.get_output(0)
 
 
-@converter_registry.register("pd_op.gather", trt_version="8.x")
+@converter_registry.register("pd_op.gather")
 def gather_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     index_tensor = inputs[1]
@@ -101,7 +101,7 @@ def gather_converter(network, paddle_op, inputs):
     return gather_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.gather_nd", trt_version="8.x")
+@converter_registry.register("pd_op.gather_nd")
 def gather_nd_converter(network, paddle_op, inputs):
     input_tensor, indices_tensor = inputs
     non_zero_layer = network.add_gather_v2(
@@ -405,8 +405,8 @@ def expand_as_converter(network, paddle_op, inputs):
     )
 
 
-@converter_registry.register("pd_op.cast", trt_version="8.x")
-@converter_registry.register("pd_op.cast_", trt_version="8.x")
+@converter_registry.register("pd_op.cast")
+@converter_registry.register("pd_op.cast_")
 def cast_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     out_dtype = int(paddle_op.attrs().get("dtype"))
@@ -624,7 +624,7 @@ def slice_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.split_with_num", trt_version="8.x")
+@converter_registry.register("pd_op.split_with_num")
 def split_with_num_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     input_shape_size = len(input_tensor.shape)
@@ -756,7 +756,7 @@ def split_with_num_converter(network, paddle_op, inputs):
     return outputs
 
 
-@converter_registry.register("pd_op.split", trt_version="8.x")
+@converter_registry.register("pd_op.split")
 def split_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     input_shape = input_tensor.shape
@@ -938,7 +938,7 @@ def split_converter(network, paddle_op, inputs):
     return outputs
 
 
-@converter_registry.register("pd_op.stack", trt_version="8.x")
+@converter_registry.register("pd_op.stack")
 def stack_converter(network, paddle_op, inputs):
     input_tensors = inputs[0]
     input_num = len(input_tensors)
@@ -1012,7 +1012,7 @@ def stack_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.tile", trt_version="8.x")
+@converter_registry.register("pd_op.tile")
 def tile_converter(network, paddle_op, inputs):
     input = inputs[0]
     input_shape = input.shape
@@ -1120,7 +1120,7 @@ def take_along_axis_converter(network, paddle_op, inputs):
     return output_tensor
 
 
-@converter_registry.register("pd_op.strided_slice", trt_version="8.x")
+@converter_registry.register("pd_op.strided_slice")
 def strided_slice_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     axes = paddle_op.attrs()["axes"]
@@ -1228,7 +1228,7 @@ def strided_slice_converter(network, paddle_op, inputs):
     return layer.get_output(0)
 
 
-@converter_registry.register("pd_op.roll", trt_version="8.x")
+@converter_registry.register("pd_op.roll")
 def roll_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     axis = paddle_op.attrs()["axis"]
@@ -1373,7 +1373,7 @@ def roll_converter(network, paddle_op, inputs):
     return layer.get_output(0)
 
 
-@converter_registry.register("pd_op.pad", trt_version="8.x")
+@converter_registry.register("pd_op.pad")
 def pad_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     paddings = paddle_op.attrs()["paddings"]
@@ -1385,7 +1385,7 @@ def pad_converter(network, paddle_op, inputs):
     return layer.get_output(0)
 
 
-@converter_registry.register("pd_op.pad3d", trt_version="8.x")
+@converter_registry.register("pd_op.pad3d")
 def pad3d_converter(network, paddle_op, inputs):
     input_tensor, paddings = inputs
     value = paddle_op.attrs().get("pad_value", 0.0)
@@ -1501,7 +1501,7 @@ def pad3d_converter(network, paddle_op, inputs):
         return slice_layer.get_output(0)
 
 
-@converter_registry.register("pd_op.numel", trt_version="8.x")
+@converter_registry.register("pd_op.numel")
 def numel_converter(network, paddle_op, inputs):
     input_tensor = inputs[0]
     shape_tensor = network.add_shape(input_tensor)
@@ -1514,7 +1514,7 @@ def numel_converter(network, paddle_op, inputs):
     return layer.get_output(0)
 
 
-@converter_registry.register("pd_op.index_put", trt_version="8.x")
+@converter_registry.register("pd_op.index_put")
 def index_put_converter(network, paddle_op, inputs):
     input_tensor, indices_list, value_tensor = inputs
     indices_tensor = indices_list[0]