diff --git a/tests/onnx/test_auto_scan_conv2d.py b/tests/onnx/test_auto_scan_conv2d.py index 7ec6c6e02283bca2b84f9854a699246297373755..c782d32af9dd619db2a7c95630497360cfa9215a 100644 --- a/tests/onnx/test_auto_scan_conv2d.py +++ b/tests/onnx/test_auto_scan_conv2d.py @@ -15,9 +15,6 @@ from auto_scan_test import OPConvertAutoScanTest from hypothesis import reproduce_failure import hypothesis.strategies as st -import onnx -from onnx import helper -from onnx import TensorProto import numpy as np import unittest diff --git a/tests/onnx/test_auto_scan_hardsigmoid.py b/tests/onnx/test_auto_scan_hardsigmoid.py new file mode 100644 index 0000000000000000000000000000000000000000..295ee0e4752090da9772e95c5297c170996b317f --- /dev/null +++ b/tests/onnx/test_auto_scan_hardsigmoid.py @@ -0,0 +1,64 @@ +# 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. + +from auto_scan_test import OPConvertAutoScanTest +from hypothesis import reproduce_failure +import hypothesis.strategies as st +import numpy as np +import unittest +import random + + +class TestHardSigmoidCovert(OPConvertAutoScanTest): + """ + ONNX op: HardSigmoid + OPset version: 7~15 + """ + + def sample_convert_config(self, draw): + input_shape = draw( + st.lists( + st.integers( + min_value=2, max_value=6), min_size=2, max_size=5)) + input_dtype = draw(st.sampled_from(["float32"])) + + alpha = random.random() + + beta = random.random() + + config = { + "op_names": ["HardSigmoid"], + "test_data_shapes": [input_shape], + "test_data_types": [[input_dtype]], + "inputs_shape": [input_shape], + "min_opset_version": 7, + "inputs_name": ["x"], + "outputs_name": ["y"], + "delta": 1e-4, + "rtol": 1e-4 + } + + attrs = { + "alpha": alpha, + "beta": beta, + } + + return (config, attrs) + + def test(self): + self.run_and_statis(max_examples=30) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/onnx/test_auto_scan_reduce_ops.py b/tests/onnx/test_auto_scan_reduce_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..3c5d9fc6d15ada1d63b81cb78233847df122ee6a --- /dev/null +++ b/tests/onnx/test_auto_scan_reduce_ops.py @@ -0,0 +1,71 @@ +# 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. + +from auto_scan_test import OPConvertAutoScanTest +from hypothesis import reproduce_failure +import hypothesis.strategies as st +import numpy as np +import unittest +import random + + +class TestReduceOpsConvert(OPConvertAutoScanTest): + """ + ONNX op: Reduce Ops + OPset version: 7~15 + """ + + def sample_convert_config(self, draw): + input_shape = draw( + st.lists( + st.integers( + min_value=20, max_value=30), min_size=3, max_size=5)) + + input_dtype = draw(st.sampled_from(["float32", "int32", "int64"])) + + axes = draw( + st.lists( + st.integers( + min_value=-len(input_shape), max_value=len(input_shape) - + 1), + min_size=1, + max_size=1)) + + keep_dim = draw(st.integers(min_value=0, max_value=1)) + config = { + "op_names": ["ReduceL1", "ReduceL2"], + "test_data_shapes": [input_shape], + "test_data_types": [input_dtype], + "inputs_shape": [input_shape], + "min_opset_version": 7, + "max_opset_version": 15, + "inputs_name": ["x"], + "outputs_name": ["y"], + "delta": 1e-4, + "rtol": 1e-4, + } + + attrs = { + "axes": axes, + "keepdims": keep_dim, + } + + return (config, attrs) + + def test(self): + self.run_and_statis(max_examples=50) + + +if __name__ == "__main__": + unittest.main() diff --git a/x2paddle/op_mapper/onnx2paddle/opset7.py b/x2paddle/op_mapper/onnx2paddle/opset7.py index 2fe457ef0ab0d32c4206f75270ccf506398980fe..cf231af72ec26bbd3b084de91d9dc9583b21f210 100644 --- a/x2paddle/op_mapper/onnx2paddle/opset7.py +++ b/x2paddle/op_mapper/onnx2paddle/opset7.py @@ -132,3 +132,69 @@ class OpSet7(OpSet): inputs={"x": val_x.name}, axis=axes, outputs=[node.name]) + + @print_mapping_info + def ReduceL1(self, node): + output_name = node.name + layer_outputs = [output_name] + val_x = self.graph.get_input_node(node, idx=0, copy=True) + axes = node.get_attr('axes') + keepdims = False if node.get_attr('keepdims') == 0 else True + layer_attrs = {'p': 1, 'axis': axes, 'keepdim': keepdims} + if val_x.dtype != 'float32' and val_x.dtype != 'float64': + indices_cast = val_x.name + '_cast' + mid_norm = val_x.name + '_norm' + self.paddle_graph.add_layer( + 'paddle.cast', + inputs={"x": val_x.name}, + outputs=[indices_cast], + dtype=string('float32')) + self.paddle_graph.add_layer( + "paddle.norm", + inputs={"x": indices_cast}, + outputs=[mid_norm], + **layer_attrs) + self.paddle_graph.add_layer( + 'paddle.cast', + inputs={"x": mid_norm}, + outputs=[node.name], + dtype=string(val_x.dtype)) + else: + self.paddle_graph.add_layer( + "paddle.norm", + inputs={"x": val_x.name}, + outputs=layer_outputs, + **layer_attrs) + + @print_mapping_info + def ReduceL2(self, node): + output_name = node.name + layer_outputs = [output_name] + val_x = self.graph.get_input_node(node, idx=0, copy=True) + axes = node.get_attr('axes') + keepdims = False if node.get_attr('keepdims') == 0 else True + layer_attrs = {'p': 2, 'axis': axes, 'keepdim': keepdims} + if val_x.dtype != 'float32' and val_x.dtype != 'float64': + indices_cast = val_x.name + '_cast' + mid_norm = val_x.name + '_norm' + self.paddle_graph.add_layer( + 'paddle.cast', + inputs={"x": val_x.name}, + outputs=[indices_cast], + dtype=string('float32')) + self.paddle_graph.add_layer( + "paddle.norm", + inputs={"x": indices_cast}, + outputs=[mid_norm], + **layer_attrs) + self.paddle_graph.add_layer( + 'paddle.cast', + inputs={"x": mid_norm}, + outputs=[node.name], + dtype=string(val_x.dtype)) + else: + self.paddle_graph.add_layer( + "paddle.norm", + inputs={"x": val_x.name}, + outputs=layer_outputs, + **layer_attrs)