【PaddlePaddle Hackathon】在Paddle2ONNX 新增11个 Paddle 2.0 API 支持

paddle2onnx/op_mapper/logic.py

@@ -87,6 +87,28 @@ def opset_1(cls, graph, node, **kw):
             outputs=node.output('Out'))
 
 
+@op_mapper('logical_not')
+class LogicalNot():
+    support_opset_version_range = (1, 12)
+
+    @classmethod
+    def opset_1(cls, graph, node, **kw):
+        graph.make_node(
+            'Not', inputs=node.input('X'), outputs=node.output('Out'))
+
+
+@op_mapper('logical_or')
+class LogicalOr():
+    support_opset_version_range = (7, 12)
+
+    @classmethod
+    def opset_7(cls, graph, node, **kw):
+        graph.make_node(
+            'Or',
+            inputs=[node.input('X', 0), node.input('Y', 0)],
+            outputs=node.output('Out'))
+
+
 @op_mapper('less_equal')
 class LessOrEqual():
     support_opset_verison_range = (12, )
@@ -120,4 +142,4 @@ def opset_10(cls, graph, node, **kw):
         is_inf = graph.make_node('IsInf', inputs=node.input('X', 0))
         is_nan = graph.make_node('IsNaN', inputs=node.input('X', 0))
         finite = graph.make_node('Or', inputs=[is_inf, is_nan])
-        graph.make_node('Not', inputs=[finite], outputs=node.output('Out'))
+        graph.make_node('Not', inputs=[finite], outputs=node.output('Out'))

paddle2onnx/op_mapper/math.py

@@ -86,6 +86,39 @@ def opset_1(cls, graph, node, **kw):
             'Abs', inputs=node.input('X'), outputs=node.output('Out'))
 
 
+@op_mapper('erf')
+class Erf():
+    support_opset_version_range = (9, 12)
+
+    @classmethod
+    def opset_9(cls, graph, node, **kw):
+        graph.make_node(
+            'Erf', inputs=node.input('X'), outputs=node.output('Out'))
+
+
+@op_mapper('isinf_v2')
+class IsInf():
+    support_opset_version_range = (10, 12)
+
+    @classmethod
+    def opset_10(cls, graph, node, **kw):
+        graph.make_node(
+            'IsInf', inputs=node.input('X'), outputs=node.output('Out'))
+
+
+@op_mapper('isnan')
+class IsNaN():
+    support_opset_version_range = (9, 12)
+
+    @classmethod
+    def opset_9(cls, graph, node, **kw):
+        isnan = graph.make_node('IsNaN', inputs=node.input('X'))
+        cast_node = graph.make_node(
+            'Cast', inputs=isnan, attrs={'to': dtypes.ONNX.FLOAT})
+        graph.make_node(
+            'ReduceMax', inputs=[cast_node], outputs=node.output('Out'))
+
+
 @op_mapper('acos')
 class Acos():
     supports_opset_version_range = (7, 12)
@@ -146,6 +179,79 @@ def opset_9(cls, graph, node, **kw):
             'Cosh', inputs=node.input('X'), outputs=node.output('Out'))
 
 
+@op_mapper('isnan_v2')
+class IsNaN():
+    support_opset_version_range = (9, 12)
+
+    @classmethod
+    def opset_9(cls, graph, node, **kw):
+        graph.make_node(
+            'IsNaN', inputs=node.input('X'), outputs=node.output('Out'))
+
+
+@op_mapper('less_than')
+class Less_than():
+    support_opset_version_range = (7, 12)
+
+    @classmethod
+    def opset_7(cls, graph, node, **kw):
+        graph.make_node(
+            'Less',
+            inputs=[node.input('X', 0), node.input('Y', 0)],
+            outputs=node.output('Out'),
+        )
+
+
+@op_mapper('log2')
+class Log2():
+    support_opset_version_range = (7, 12)
+
+    @classmethod
+    def opset_7(cls, graph, node, **kw):
+        two = graph.make_node(
+            'Constant', attrs={
+                'dtype': dtypes.ONNX.FLOAT,
+                'value': [2]
+            })
+        ln2 = graph.make_node('Log', inputs=[two])
+        lnx = graph.make_node('Log', inputs=node.input('X'))
+        graph.make_node('Div', inputs=[lnx, ln2], outputs=node.output('Out'))
+
+
+@op_mapper('logsumexp')
+class LogSumExp():
+    support_opset_version_range = (1, 12)
+
+    @classmethod
+    def opset_1(cls, graph, node, **kw):
+
+        if node.attr('reduce_all'):
+            if not node.attr('keepdim'):
+                reduce_node = graph.make_node(
+                    'ReduceLogSumExp',
+                    inputs=node.input('X'),
+                    keepdims=node.attr('keepdim'),
+                )
+                graph.make_node(
+                    'Unsqueeze',
+                    inputs=[reduce_node],
+                    axes=[0],
+                    outputs=node.output('Out'))
+            else:
+                graph.make_node(
+                    'ReduceLogSumExp',
+                    inputs=node.input('X'),
+                    keepdims=node.attr('keepdim'),
+                    outputs=node.output('Out'))
+        else:
+            graph.make_node(
+                'ReduceLogSumExp',
+                inputs=node.input('X'),
+                keepdims=node.attr('keepdim'),
+                axes=node.attr('axis'),
+                outputs=node.output('Out'))
+
+
 @op_mapper(
     [
         'elementwise_add',

tests/test_erf.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2021  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 paddle
+from onnxbase import APIOnnx
+from onnxbase import randtool
+
+
+class Net(paddle.nn.Layer):
+    """
+    simplr Net
+    """
+
+    def __init__(self):
+        super(Net, self).__init__()
+
+    def forward(self, inputs):
+        """
+        forward
+        """
+        x = paddle.erf(inputs)
+        return x
+
+
+def test_erf_9():
+    """
+    api: paddle.erf
+    op version: 9
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'erf', [9])
+    obj.set_input_data(
+        "input_data",
+        paddle.to_tensor(randtool("float", -1, 1, [3, 3]).astype('float32')))
+    obj.run()
+
+
+def test_erf_10():
+    """
+    api: paddle.erf
+    op version: 10
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'erf', [10])
+    obj.set_input_data(
+        "input_data",
+        paddle.to_tensor(randtool("float", -1, 1, [3, 3]).astype('float32')))
+    obj.run()
+
+
+def test_erf_11():
+    """
+    api: paddle.erf
+    op version: 11
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'erf', [11])
+    obj.set_input_data(
+        "input_data",
+        paddle.to_tensor(randtool("float", -1, 1, [3, 3]).astype('float32')))
+    obj.run()
+
+
+def test_erf_12():
+    """
+    api: paddle.erf
+    op version: 12
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'erf', [12])
+    obj.set_input_data(
+        "input_data",
+        paddle.to_tensor(randtool("float", -1, 1, [3, 3]).astype('float32')))
+    obj.run()

tests/test_floor_mod.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2021  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 paddle
+from onnxbase import APIOnnx
+from onnxbase import randtool
+
+
+class Net(paddle.nn.Layer):
+    """
+    simplr Net
+    """
+
+    def __init__(self):
+        super(Net, self).__init__()
+
+    def forward(self, inputs, _inputs):
+        """
+        forward
+        """
+        x = paddle.floor_mod(inputs, _inputs)
+        return x
+
+
+def test_floor_mod_10():
+    """
+    api: paddle.floor_mod
+    op version: 10
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'floor_mod', [10])
+    obj.set_input_data("input_data", paddle.to_tensor([2, 3, 8, 7]),
+                       paddle.to_tensor([1, 5, 3, 3]))
+    obj.run()
+
+
+def test_floor_mod_12():
+    """
+    api: paddle.floor_mod
+    op version: 12
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'floor_mod', [12])
+    obj.set_input_data("input_data", paddle.to_tensor([2, 3, 8, 7]),
+                       paddle.to_tensor([1, 5, 3, 3]))
+    obj.run()
+
+
+def test_floor_mod_broadcasting():
+    """
+    api: paddle.floor_mod
+    op version: 12
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'floor_mod', [12])
+    obj.set_input_data("input_data", paddle.to_tensor([2, 3, 8, 7]),
+                       paddle.to_tensor([3]))
+    obj.run()

tests/test_has_nan.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2021  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 paddle
+from onnxbase import APIOnnx
+from onnxbase import randtool
+
+
+class Net(paddle.nn.Layer):
+    """
+    simplr Net
+    """
+
+    def __init__(self):
+        super(Net, self).__init__()
+
+    def forward(self, inputs):
+        """
+        forward
+        """
+        x = paddle.fluid.layers.has_nan(inputs)
+        return x.astype('float32')
+
+
+def test_has_nan_base():
+    """
+    api: paddle.fluid.layers.has_nan
+    op version: 9, 10, 12
+    """
+    op = Net()
+    op.eval()
+    # net, name, ver_list, delta=1e-6, rtol=1e-5
+    obj = APIOnnx(op, 'has_nan', [9, 10, 12])
+    obj.set_input_data(
+        "input_data",
+        paddle.to_tensor(([
+            float('-inf'), -2, 3.6,
+            float('inf'), 0,
+            float('-nan'),
+            float('nan')
+        ])))
+    obj.run()