Merge pull request #897 from RandySheriffH/rashuai/opset12

opset 12 support

Author: RandySheriffH

ci_build/azure_pipelines/pylint.yml

@@ -8,7 +8,7 @@ jobs:
       steps:
       - bash: |
           set -ex
-          pip install pylint
+          pip install pylint==2.4.4
           pip freeze
           pylint --rcfile=tools/pylintrc --ignore=version.py --disable=cyclic-import tf2onnx tests/*.py tools -j 0
         displayName: 'Pylint'

tests/test_backend.py

@@ -3130,6 +3130,40 @@ def func(X, K):
                 k_val = np.array(raw_k).astype(np.int32)
                 self._run_test_case(func, [_OUTPUT, _OUTPUT1], {_INPUT: x_val, _INPUT1: k_val})
 
+    @check_opset_min_version(12)
+    def test_inverse(self):
+        x_val = np.random.random([5, 5]).astype(np.float32)
+        def func(x):
+            return tf.linalg.inv(x, name=_TFOUTPUT)
+        self._run_test_case(func, [_OUTPUT], {_INPUT: x_val})
+
+    @check_opset_min_version(12)
+    def test_squared_distance(self):
+        x_val = np.random.random([4, 5]).astype(np.float32)
+        y_val = np.random.random([4, 5]).astype(np.float32)
+        def func(x, y):
+            return tf.math.squared_difference(x, y, name=_TFOUTPUT)
+        self._run_test_case(func, [_OUTPUT], {_INPUT: x_val, _INPUT1: y_val})
+
+    @check_opset_min_version(12)
+    @check_tf_min_version("2.1")
+    def test_einsum(self):
+        x_val = np.random.random([10]).astype(np.float32)
+        y_val = np.random.random([10]).astype(np.float32)
+        def func(x, y):
+            ret = tf.einsum("i,j->ij", x, y)
+            return tf.identity(ret, name=_TFOUTPUT)
+        self._run_test_case(func, [_OUTPUT], {_INPUT: x_val, _INPUT1: y_val})
+
+    @check_opset_min_version(7)
+    def test_compare(self):
+        x_val = np.random.random([10, 20]).astype(np.float32)
+        y_val = np.random.random([10, 20]).astype(np.float32)
+        def func(x, y):
+            return tf.math.less_equal(x, y, name=_TFOUTPUT), \
+                   tf.math.greater_equal(x, y, name=_TFOUTPUT1)
+        self._run_test_case(func, [_OUTPUT, _OUTPUT1], {_INPUT: x_val, _INPUT1: y_val})
+
 
 if __name__ == '__main__':
     unittest_main()

tf2onnx/custom_opsets/ms.py

@@ -103,3 +103,11 @@ def version_11(cls, ctx, node, **kwargs):
         ctx.insert_new_node_on_input(node, "Transpose", node.input[0], perm=constants.NHWC_TO_NCHW)
         ctx.insert_new_node_on_output("Transpose", node.output[0], node.name + '_transposed',
                                       None, perm=constants.NCHW_TO_NHWC)
+
+@tf_op("MatrixInverse", domain=constants.MICROSOFT_DOMAIN, onnx_op="Inverse")
+class Inverse:
+    @classmethod
+    def version_12(cls, ctx, node, **kwargs):
+        utils.make_sure(node.get_attr('adjoint').i == 0, "adjoint must be false")
+        del node.attr["adjoint"]
+        node.domain = constants.MICROSOFT_DOMAIN

tf2onnx/onnx_opset/logical.py

@@ -110,14 +110,17 @@ def version_7(cls, ctx, node, **kwargs):
         target_dtype = TensorProto.FLOAT
         _add_cast_to_inputs(ctx, node, supported_dtypes, target_dtype)
 
-
-@tf_op("GreaterEqual", onnx_op="Less")
-@tf_op("LessEqual", onnx_op="Greater")
+@tf_op(["GreaterEqual", "LessEqual"])
 class GreaterLessEqual:
     @classmethod
     def version_7(cls, ctx, node, **kwargs):
         GreaterLess.version_7(ctx, node, **kwargs)
         output_name = node.output[0]
+        node.op.op_type = "Less" if node.op.op_type == "GreaterEqual" else "Greater"
         new_node = ctx.insert_new_node_on_output("Not", output_name, name=utils.make_name(node.name))
         ctx.copy_shape(output_name, new_node.output[0])
         ctx.set_dtype(new_node.output[0], ctx.get_dtype(output_name))
+
+    @classmethod
+    def version_12(cls, ctx, node, **kwargs):
+        node.op.op_type = "GreaterOrEqual" if node.op.op_type == "GreaterEqual" else "LessOrEqual"

tf2onnx/onnx_opset/math.py

@@ -544,3 +544,26 @@ def version_11(cls, ctx, node, **kwargs):
             cast_back_node.set_attr("to", dtypes[0])
             ctx.set_dtype(cast_back_node.output[0], dtypes[0])
             ctx.copy_shape(node.name, cast_back_node.output[0])
+
+
+@tf_op("SquaredDistance", onnx_op="MeanSquaredDistance")
+class SquaredDistance:
+    @classmethod
+    def version_12(cls, ctx, node, **kwargs):
+        node.attr["reduction"] = "none"
+
+
+@tf_op("Einsum")
+class Einsum:
+    @classmethod
+    def version_12(cls, ctx, node, **kwargs):
+        del node.attr["N"]
+
+
+@tf_op("MatrixInverse", onnx_op="Inverse")
+class Inverse:
+    @classmethod
+    def version_12(cls, ctx, node, **kwargs):
+        utils.make_sure(node.get_attr('adjoint').i == 0, "adjoint must be false")
+        del node.attr["adjoint"]
+        node.domain = constants.MICROSOFT_DOMAIN