From b7496bcb982ab40ddbf958bc223338303c447f40 Mon Sep 17 00:00:00 2001 From: fwenguang <95677191+fwenguang@users.noreply.github.com> Date: Fri, 29 Jul 2022 11:00:54 +0800 Subject: [PATCH] [MLU] add pytest for mlu strided_slice kernel (#44523) --- .../mlu/test_strided_slice_op_mlu.py | 632 ++++++++++++++++++ 1 file changed, 632 insertions(+) create mode 100644 python/paddle/fluid/tests/unittests/mlu/test_strided_slice_op_mlu.py diff --git a/python/paddle/fluid/tests/unittests/mlu/test_strided_slice_op_mlu.py b/python/paddle/fluid/tests/unittests/mlu/test_strided_slice_op_mlu.py new file mode 100644 index 00000000000..21388f1131f --- /dev/null +++ b/python/paddle/fluid/tests/unittests/mlu/test_strided_slice_op_mlu.py @@ -0,0 +1,632 @@ +# Copyright (c) 2022 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 sys + +sys.path.append('..') +from op_test import OpTest +from test_strided_slice_op import strided_slice_native_forward +import numpy as np +import unittest +import paddle.fluid as fluid +import paddle + +paddle.enable_static() + + +class TestStrideSliceOp(OpTest): + + def setUp(self): + self.initTestCase() + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.op_type = 'strided_slice' + self.python_api = paddle.strided_slice + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + self.inputs = {'Input': self.input} + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + 'starts': self.starts, + 'ends': self.ends, + 'strides': self.strides, + 'infer_flags': self.infer_flags + } + + def test_check_output(self): + self.check_output_with_place(self.place, check_eager=False) + + def test_check_grad(self): + self.check_grad_with_place(self.place, + set(['Input']), + 'Out', + check_eager=False) + + def initTestCase(self): + self.input = np.random.rand(100).astype(np.float32) + self.axes = [0] + self.starts = [-4] + self.ends = [-3] + self.strides = [1] + self.infer_flags = [1] + + +class TestStrideSliceOp1(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(100).astype(np.float32) + self.axes = [0] + self.starts = [3] + self.ends = [8] + self.strides = [1] + self.infer_flags = [1] + + +class TestStrideSliceOp2(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(100).astype(np.float32) + self.axes = [0] + self.starts = [5] + self.ends = [0] + self.strides = [-1] + self.infer_flags = [1] + + +class TestStrideSliceOp3(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(100).astype(np.float32) + self.axes = [0] + self.starts = [-1] + self.ends = [-3] + self.strides = [-1] + self.infer_flags = [1] + + +class TestStrideSliceOp4(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(3, 4, 10).astype(np.float32) + self.axes = [0, 1, 2] + self.starts = [0, -1, 0] + self.ends = [2, -3, 5] + self.strides = [1, -1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOp5(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(5, 5, 5).astype(np.float32) + self.axes = [0, 1, 2] + self.starts = [1, 0, 0] + self.ends = [2, 1, 3] + self.strides = [1, 1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOp6(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(5, 5, 5).astype(np.float32) + self.axes = [0, 1, 2] + self.starts = [1, -1, 0] + self.ends = [2, -3, 3] + self.strides = [1, -1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOp7(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(5, 5, 5).astype(np.float32) + self.axes = [0, 1, 2] + self.starts = [1, 0, 0] + self.ends = [2, 2, 3] + self.strides = [1, 1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOp8(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(1, 100, 1).astype(np.float32) + self.axes = [1] + self.starts = [1] + self.ends = [2] + self.strides = [1] + self.infer_flags = [1] + + +class TestStrideSliceOp9(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(1, 100, 1).astype(np.float32) + self.axes = [1] + self.starts = [-1] + self.ends = [-2] + self.strides = [-1] + self.infer_flags = [1] + + +class TestStrideSliceOp10(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(10, 10).astype(np.float32) + self.axes = [0, 1] + self.starts = [1, 0] + self.ends = [2, 2] + self.strides = [1, 1] + self.infer_flags = [1, 1] + + +class TestStrideSliceOp11(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 4).astype(np.float32) + self.axes = [0, 1, 2, 3] + self.starts = [1, 0, 0, 0] + self.ends = [2, 2, 3, 4] + self.strides = [1, 1, 1, 2] + self.infer_flags = [1, 1, 1, 1] + + +class TestStrideSliceOp12(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 4, 5).astype(np.float32) + self.axes = [0, 1, 2, 3, 4] + self.starts = [1, 0, 0, 0, 0] + self.ends = [2, 2, 3, 4, 4] + self.strides = [1, 1, 1, 1, 1] + self.infer_flags = [1, 1, 1, 1] + + +class TestStrideSliceOp13(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 6, 7, 8).astype(np.float32) + self.axes = [0, 1, 2, 3, 4, 5] + self.starts = [1, 0, 0, 0, 1, 2] + self.ends = [2, 2, 3, 1, 2, 8] + self.strides = [1, 1, 1, 1, 1, 2] + self.infer_flags = [1, 1, 1, 1, 1] + + +class TestStrideSliceOp14(TestStrideSliceOp): + + def initTestCase(self): + self.input = np.random.rand(4, 4, 4, 4).astype(np.float32) + self.axes = [1, 2, 3] + self.starts = [-5, 0, -7] + self.ends = [-1, 2, 4] + self.strides = [1, 1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOpBool(TestStrideSliceOp): + + def test_check_grad(self): + pass + + +class TestStrideSliceOpBool1D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(100).astype("bool") + self.axes = [0] + self.starts = [3] + self.ends = [8] + self.strides = [1] + self.infer_flags = [1] + + +class TestStrideSliceOpBool2D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(10, 10).astype("bool") + self.axes = [0, 1] + self.starts = [1, 0] + self.ends = [2, 2] + self.strides = [1, 1] + self.infer_flags = [1, 1] + + +class TestStrideSliceOpBool3D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(3, 4, 10).astype("bool") + self.axes = [0, 1, 2] + self.starts = [0, -1, 0] + self.ends = [2, -3, 5] + self.strides = [1, -1, 1] + self.infer_flags = [1, 1, 1] + + +class TestStrideSliceOpBool4D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 4).astype("bool") + self.axes = [0, 1, 2, 3] + self.starts = [1, 0, 0, 0] + self.ends = [2, 2, 3, 4] + self.strides = [1, 1, 1, 2] + self.infer_flags = [1, 1, 1, 1] + + +class TestStrideSliceOpBool5D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 4, 5).astype("bool") + self.axes = [0, 1, 2, 3, 4] + self.starts = [1, 0, 0, 0, 0] + self.ends = [2, 2, 3, 4, 4] + self.strides = [1, 1, 1, 1, 1] + self.infer_flags = [1, 1, 1, 1] + + +class TestStrideSliceOpBool6D(TestStrideSliceOpBool): + + def initTestCase(self): + self.input = np.random.rand(3, 3, 3, 6, 7, 8).astype("bool") + self.axes = [0, 1, 2, 3, 4, 5] + self.starts = [1, 0, 0, 0, 1, 2] + self.ends = [2, 2, 3, 1, 2, 8] + self.strides = [1, 1, 1, 1, 1, 2] + self.infer_flags = [1, 1, 1, 1, 1] + + +class TestStridedSliceOp_starts_ListTensor(OpTest): + + def setUp(self): + self.op_type = "strided_slice" + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.config() + + starts_tensor = [] + for index, ele in enumerate(self.starts): + starts_tensor.append(("x" + str(index), np.ones( + (1)).astype('int32') * ele)) + + self.inputs = {'Input': self.input, 'StartsTensorList': starts_tensor} + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + 'starts': self.starts_infer, + 'ends': self.ends, + 'strides': self.strides, + 'infer_flags': self.infer_flags + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, 0, 2] + self.ends = [3, 3, 4] + self.axes = [0, 1, 2] + self.strides = [1, 1, 1] + self.infer_flags = [1, -1, 1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + self.starts_infer = [1, 10, 2] + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +class TestStridedSliceOp_ends_ListTensor(OpTest): + + def setUp(self): + self.op_type = "strided_slice" + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.config() + + ends_tensor = [] + for index, ele in enumerate(self.ends): + ends_tensor.append(("x" + str(index), np.ones( + (1)).astype('int32') * ele)) + + self.inputs = {'Input': self.input, 'EndsTensorList': ends_tensor} + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + 'starts': self.starts, + 'ends': self.ends_infer, + 'strides': self.strides, + 'infer_flags': self.infer_flags + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, 0, 0] + self.ends = [3, 3, 4] + self.axes = [0, 1, 2] + self.strides = [1, 1, 2] + self.infer_flags = [1, -1, 1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + self.ends_infer = [3, 1, 4] + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +class TestStridedSliceOp_starts_Tensor(OpTest): + + def setUp(self): + self.op_type = "strided_slice" + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.config() + self.inputs = { + 'Input': self.input, + "StartsTensor": np.array(self.starts, dtype="int32") + } + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + #'starts': self.starts, + 'ends': self.ends, + 'strides': self.strides, + 'infer_flags': self.infer_flags, + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, 0, 2] + self.ends = [2, 3, 4] + self.axes = [0, 1, 2] + self.strides = [1, 1, 1] + self.infer_flags = [-1, -1, -1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +class TestStridedSliceOp_ends_Tensor(OpTest): + + def setUp(self): + self.op_type = "strided_slice" + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.config() + self.inputs = { + 'Input': self.input, + "EndsTensor": np.array(self.ends, dtype="int32") + } + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + 'starts': self.starts, + #'ends': self.ends, + 'strides': self.strides, + 'infer_flags': self.infer_flags, + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, 0, 2] + self.ends = [2, 3, 4] + self.axes = [0, 1, 2] + self.strides = [1, 1, 1] + self.infer_flags = [-1, -1, -1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +class TestStridedSliceOp_listTensor_Tensor(OpTest): + + def setUp(self): + self.config() + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + ends_tensor = [] + for index, ele in enumerate(self.ends): + ends_tensor.append(("x" + str(index), np.ones( + (1)).astype('int32') * ele)) + self.op_type = "strided_slice" + + self.inputs = { + 'Input': self.input, + "StartsTensor": np.array(self.starts, dtype="int32"), + "EndsTensorList": ends_tensor + } + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + #'starts': self.starts, + #'ends': self.ends, + 'strides': self.strides, + 'infer_flags': self.infer_flags, + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, 0, 2] + self.ends = [2, 3, 4] + self.axes = [0, 1, 2] + self.strides = [1, 1, 1] + self.infer_flags = [-1, -1, -1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +class TestStridedSliceOp_strides_Tensor(OpTest): + + def setUp(self): + self.op_type = "strided_slice" + self.place = paddle.device.MLUPlace(0) + self.__class__.use_mlu = True + self.config() + self.inputs = { + 'Input': self.input, + "StridesTensor": np.array(self.strides, dtype="int32") + } + self.outputs = {'Out': self.output} + self.attrs = { + 'axes': self.axes, + 'starts': self.starts, + 'ends': self.ends, + #'strides': self.strides, + 'infer_flags': self.infer_flags, + } + + def config(self): + self.input = np.random.random([3, 4, 5, 6]).astype("float32") + self.starts = [1, -1, 2] + self.ends = [2, 0, 4] + self.axes = [0, 1, 2] + self.strides = [1, -1, 1] + self.infer_flags = [-1, -1, -1] + self.output = strided_slice_native_forward(self.input, self.axes, + self.starts, self.ends, + self.strides) + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad_normal(self): + self.check_grad_with_place(self.place, ['Input'], + 'Out', + max_relative_error=0.006) + + +# Test python API +class TestStridedSliceAPI(unittest.TestCase): + + def test_1(self): + input = np.random.random([3, 4, 5, 6]).astype("float32") + minus_1 = fluid.layers.fill_constant([1], "int32", -1) + minus_3 = fluid.layers.fill_constant([1], "int32", -3) + starts = fluid.layers.data(name='starts', + shape=[3], + dtype='int32', + append_batch_size=False) + ends = fluid.layers.data(name='ends', + shape=[3], + dtype='int32', + append_batch_size=False) + strides = fluid.layers.data(name='strides', + shape=[3], + dtype='int32', + append_batch_size=False) + + x = fluid.layers.data(name="x", + shape=[3, 4, 5, 6], + append_batch_size=False, + dtype="float32") + out_1 = paddle.strided_slice(x, + axes=[0, 1, 2], + starts=[-3, 0, 2], + ends=[3, 100, -1], + strides=[1, 1, 1]) + out_2 = paddle.strided_slice(x, + axes=[0, 1, 3], + starts=[minus_3, 0, 2], + ends=[3, 100, -1], + strides=[1, 1, 1]) + out_3 = paddle.strided_slice(x, + axes=[0, 1, 3], + starts=[minus_3, 0, 2], + ends=[3, 100, minus_1], + strides=[1, 1, 1]) + out_4 = paddle.strided_slice(x, + axes=[0, 1, 2], + starts=starts, + ends=ends, + strides=strides) + + out_5 = x[-3:3, 0:100:2, -1:2:-1] + out_6 = x[minus_3:3:1, 0:100:2, :, minus_1:2:minus_1] + out_7 = x[minus_1, 0:100:2, :, -1:2:-1] + + exe = fluid.Executor(place=fluid.MLUPlace(0)) + res_1, res_2, res_3, res_4, res_5, res_6, res_7 = exe.run( + fluid.default_main_program(), + feed={ + "x": input, + 'starts': np.array([-3, 0, 2]).astype("int32"), + 'ends': np.array([3, 2147483648, -1]).astype("int64"), + 'strides': np.array([1, 1, 1]).astype("int32") + }, + fetch_list=[out_1, out_2, out_3, out_4, out_5, out_6, out_7]) + assert np.array_equal(res_1, input[-3:3, 0:100, 2:-1, :]) + assert np.array_equal(res_2, input[-3:3, 0:100, :, 2:-1]) + assert np.array_equal(res_3, input[-3:3, 0:100, :, 2:-1]) + assert np.array_equal(res_4, input[-3:3, 0:100, 2:-1, :]) + assert np.array_equal(res_5, input[-3:3, 0:100:2, -1:2:-1, :]) + assert np.array_equal(res_6, input[-3:3, 0:100:2, :, -1:2:-1]) + assert np.array_equal(res_7, input[-1, 0:100:2, :, -1:2:-1]) + + def test_dygraph_op(self): + x = paddle.zeros(shape=[3, 4, 5, 6], dtype="float32") + axes = [1, 2, 3] + starts = [-3, 0, 2] + ends = [3, 2, 4] + strides_1 = [1, 1, 1] + sliced_1 = paddle.strided_slice(x, + axes=axes, + starts=starts, + ends=ends, + strides=strides_1) + assert sliced_1.shape == (3, 2, 2, 2) + + +if __name__ == "__main__": + unittest.main() -- GitLab