chore: import upstream snapshot with attribution

test/tensorrt/test_converter_common.py

@@ -0,0 +1,742 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import numpy as np
+from tensorrt_test_base import TensorRTBaseTest
+
+import paddle
+from paddle import _C_ops
+
+
+def dropout_wrapper(x, p, mode):
+    out = _C_ops.dropout(
+        x,
+        None,
+        p,
+        True,
+        mode,
+        0,
+        True,
+    )
+    return out
+
+
+class TestDropoutWithUpscaleModeTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = dropout_wrapper
+        self.api_args = {
+            "x": np.random.random([1, 2, 3]).astype("float32"),
+            "p": 0,
+            "mode": "upscale_in_train",
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 2, 3]}
+        self.opt_shape = {"x": [1, 2, 3]}
+        self.max_shape = {"x": [10, 2, 3]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestDropoutWithDowngradeModeTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = dropout_wrapper
+        self.api_args = {
+            "x": np.random.random([1, 2, 3]).astype("float32"),
+            "p": 0,
+            "mode": "downgrade_in_infer",
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 2, 3]}
+        self.opt_shape = {"x": [1, 2, 3]}
+        self.max_shape = {"x": [10, 2, 3]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+def upsample_bilinear(x):
+    upsample = paddle.nn.Upsample(size=[12, 12], mode="bilinear")
+    return upsample(x)
+
+
+def bilinear_python_api(x, OutSize, SizeTensor, Scale, attrs):
+    return _C_ops.bilinear_interp(
+        x,
+        OutSize,
+        SizeTensor,
+        Scale,
+        attrs['data_layout'],
+        attrs['out_d'],
+        attrs['out_h'],
+        attrs['out_w'],
+        attrs['scale'] if 'scale' in attrs else [],
+        attrs['interp_method'],
+        attrs['align_corners'],
+        attrs['align_mode'],
+    )
+
+
+def nearest_python_api(x, OutSize, SizeTensor, Scale, attrs):
+    return _C_ops.nearest_interp(
+        x,
+        OutSize,
+        SizeTensor,
+        Scale,
+        attrs['data_layout'],
+        attrs['out_d'],
+        attrs['out_h'],
+        attrs['out_w'],
+        attrs['scale'] if 'scale' in attrs else [],
+        attrs['interp_method'],
+        attrs['align_corners'],
+        attrs['align_mode'],
+    )
+
+
+def embedding_python_api(x, weight, attrs):
+    return _C_ops.embedding(
+        x,
+        weight,
+        attrs['padding_idx'],
+        attrs['sparse'],
+    )
+
+
+def unbind_python_api(x, attrs):
+    return _C_ops.unbind(
+        x,
+        attrs['axis'],
+    )
+
+
+class TestBilinearScaleTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = bilinear_python_api
+        self.api_args = {
+            "x": np.random.random([2, 3, 6, 10]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NCHW",
+                "scale": [2.0, 2.0],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "bilinear",
+                "align_corners": True,
+                "align_mode": 1,
+            },
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestBilinearNHWCTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = bilinear_python_api
+        x_nchw = np.random.random([2, 3, 6, 10]).astype("float32")
+        x_nhwc = np.transpose(x_nchw, (0, 2, 3, 1))
+        self.api_args = {
+            "x": x_nhwc,
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NHWC",
+                "scale": [],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "bilinear",
+                "align_corners": False,
+                "align_mode": 0,
+            },
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 6, 10, 3]}
+        self.opt_shape = {"x": [2, 6, 10, 3]}
+        self.max_shape = {"x": [12, 6, 10, 3]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestBilinearOutSizeTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = bilinear_python_api
+        self.api_args = {
+            "x": np.random.random([2, 3, 6, 10]).astype("float32"),
+            "OutSize": np.array([12, 12], dtype="int32"),
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NCHW",
+                "scale": [],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "bilinear",
+                "align_corners": False,
+                "align_mode": 0,
+            },
+        }
+        self.program_config = {"feed_list": ["x", "OutSize"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+def bilinear_python_size_tensor_api(x, OutSize, SizeTensor, Scale, attrs):
+    if SizeTensor is None:
+        if SizeTensor is None:
+            if not isinstance(x, paddle.Tensor):
+                x = paddle.to_tensor(x)
+            shape_tensor = paddle.shape(x)
+            SizeTensor = [shape_tensor[2:3], shape_tensor[3:4]]
+    return _C_ops.bilinear_interp(
+        x,
+        OutSize,
+        SizeTensor,
+        Scale,
+        attrs['data_layout'],
+        attrs['out_d'],
+        attrs['out_h'],
+        attrs['out_w'],
+        attrs['scale'] if 'scale' in attrs else [],
+        attrs['interp_method'],
+        attrs['align_corners'],
+        attrs['align_mode'],
+    )
+
+
+class TestBilinearSizeTensorTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = bilinear_python_size_tensor_api
+        self.api_args = {
+            "x": np.random.random([2, 3, 6, 10]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NCHW",
+                "scale": [],
+                "out_h": -1,
+                "out_w": -1,
+                "out_d": -1,
+                "interp_method": "bilinear",
+                "align_corners": False,
+                "align_mode": 0,
+            },
+        }
+        self.program_config = {
+            "feed_list": ["x", "OutSize", "SizeTensor", "Scale"]
+        }
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestNearestNHWCTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = nearest_python_api
+        x_nchw = np.random.random([2, 3, 6, 10]).astype("float32")
+        x_nhwc = np.transpose(x_nchw, (0, 2, 3, 1))
+        self.api_args = {
+            "x": x_nhwc,
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NHWC",
+                "scale": [],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "nearest",
+                "align_corners": False,
+                "align_mode": 1,
+            },
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 6, 10, 3]}
+        self.opt_shape = {"x": [2, 6, 10, 3]}
+        self.max_shape = {"x": [12, 6, 10, 3]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestNearestSizeTensorTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = nearest_python_api
+        x_nchw = np.random.random([2, 3, 6, 10]).astype("float32")
+        self.api_args = {
+            "x": x_nchw,
+            "OutSize": None,
+            "SizeTensor": [
+                np.array([12], dtype="int64"),
+                np.array([12], dtype="int64"),
+            ],
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NCHW",
+                "scale": [],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "nearest",
+                "align_corners": False,
+                "align_mode": 0,
+            },
+        }
+        self.program_config = {"feed_list": ["x", "SizeTensor"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestEmbeddingTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = embedding_python_api
+        x = np.array([[3, 16, 24], [6, 4, 47]]).astype(np.int64)
+        weight = np.random.uniform(-1, 1, [64, 4]).astype('float32')
+        self.api_args = {
+            "x": x,
+            "weight": weight,
+            "attrs": {
+                "padding_idx": -1,
+                "sparse": False,
+            },
+        }
+        self.dynamic_shape_data = {
+            "x": lambda shape: np.random.randint(1, 64, size=shape).astype(
+                "int64"
+            ),
+            "weight": lambda shape: np.random.randint(-1, 1, size=shape).astype(
+                "float32"
+            ),
+        }
+        self.program_config = {"feed_list": ["x", "weight"]}
+        self.min_shape = {"x": [1, 3], "weight": [64, 4]}
+        self.opt_shape = {"x": [2, 3], "weight": [64, 4]}
+        self.max_shape = {"x": [16, 3], "weight": [64, 4]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_trt_result_fp16(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestUnbindTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = unbind_python_api
+        x = np.random.random([3, 400, 196, 80]).astype(np.float32)
+        self.api_args = {
+            "x": x,
+            "attrs": {
+                "axis": 1,
+            },
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {
+            "x": [1, 400, 196, 80],
+        }
+        self.opt_shape = {"x": [2, 400, 196, 80]}
+        self.max_shape = {"x": [3, 400, 196, 80]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_trt_result_fp16(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestNearestOutAndScaleTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = nearest_python_api
+        x_nchw = np.random.random([2, 3, 6, 10]).astype("float32")
+        self.api_args = {
+            "x": x_nchw,
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "attrs": {
+                "data_layout": "NCHW",
+                "scale": [2, 2],
+                "out_h": 12,
+                "out_w": 12,
+                "out_d": -1,
+                "interp_method": "nearest",
+                "align_corners": True,
+                "align_mode": 1,
+            },
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+class TestBilinearTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = upsample_bilinear
+        self.api_args = {"x": np.random.random([2, 3, 6, 10]).astype("float32")}
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+def upsample_nearest(x):
+    upsample = paddle.nn.Upsample(size=[12, 12], mode="nearest")
+    return upsample(x)
+
+
+class TestNearestInterpTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = upsample_nearest
+        self.api_args = {"x": np.random.random([2, 3, 6, 10]).astype("float32")}
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [2, 3, 6, 10]}
+        self.opt_shape = {"x": [2, 3, 6, 10]}
+        self.max_shape = {"x": [12, 3, 6, 10]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+
+def linear_interp_test(
+    x,
+    OutSize=None,
+    SizeTensor=None,
+    Scale=None,
+    data_layout='NCHW',
+    out_d=-1,
+    out_h=-1,
+    out_w=-1,
+    scale=[],
+    interp_method='linear',
+    align_corners=True,
+    align_mode=0,
+):
+    return paddle._C_ops.linear_interp(
+        x,
+        OutSize,
+        SizeTensor,
+        Scale,
+        data_layout,
+        out_d,
+        out_h,
+        out_w,
+        scale,
+        interp_method,
+        align_corners,
+        align_mode,
+    )
+
+
+class TestLinearInterpTRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NCHW",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": False,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [3, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase1TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NHWC",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": False,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [3, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase2TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NHWC",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": False,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [3, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase3TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NHWC",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": True,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [3, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase4TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 3, 64]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NCHW",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": -1,
+            "scale": [1.0],
+            "interp_method": "linear",
+            "align_corners": False,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x", "Scale"]}
+        self.min_shape = {"x": [1, 3, 64]}
+        self.opt_shape = {"x": [2, 3, 64]}
+        self.max_shape = {"x": [4, 3, 64]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase5TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 3, 64]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": None,
+            "Scale": None,
+            "data_layout": "NHWC",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": -1,
+            "scale": [1.0],
+            "interp_method": "linear",
+            "align_corners": True,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x"]}
+        self.min_shape = {"x": [1, 3, 64]}
+        self.opt_shape = {"x": [2, 3, 64]}
+        self.max_shape = {"x": [4, 3, 64]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase6TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": np.array([288], dtype="int32"),
+            "SizeTensor": [
+                np.array([288], dtype="int64"),
+            ],
+            "Scale": None,
+            "data_layout": "NHWC",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": True,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x", "OutSize", "SizeTensor"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [4, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase7TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": np.array([288], dtype="int32"),
+            "SizeTensor": [
+                np.array([288], dtype="int64"),
+            ],
+            "Scale": None,
+            "data_layout": "NCHW",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": True,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x", "OutSize", "SizeTensor"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [4, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+class TestLinearInterpCase8TRTPattern(TensorRTBaseTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.api_args = {
+            "x": np.random.random([1, 18, 144]).astype("float32"),
+            "OutSize": None,
+            "SizeTensor": [
+                np.array([288], dtype="int64"),
+            ],
+            "Scale": None,
+            "data_layout": "NCHW",
+            "out_d": -1,
+            "out_h": -1,
+            "out_w": 288,
+            "scale": [],
+            "interp_method": "linear",
+            "align_corners": True,
+            "align_mode": 0,
+        }
+        self.program_config = {"feed_list": ["x", "SizeTensor"]}
+        self.min_shape = {"x": [1, 18, 144]}
+        self.opt_shape = {"x": [2, 18, 144]}
+        self.max_shape = {"x": [4, 18, 144]}
+
+    def test_trt_result(self):
+        self.check_trt_result()
+
+    def test_fp16_trt_result(self):
+        self.check_trt_result(precision_mode="fp16")
+
+
+if __name__ == "__main__":
+    unittest.main()