migrate ms ReverseSequence for onnx opset 10

Author: nbcsm

tests/test_backend.py

@@ -1683,19 +1683,17 @@ def test_erf(self):
             _ = tf.identity(x_, name=_TFOUTPUT)
             self._run_test_case([_OUTPUT], {_INPUT: x_val}, rtol=0.01)
 
-    def _test_reverse_sequence_batch_major(self, extra_opset=None):
-        process_args = {}
-        if extra_opset is not None:
-            process_args["extra_opset"] = [extra_opset]
-
+    @check_opset_min_version(8, "Scan")
+    @skip_opset(9, "ReverseSequence")
+    def test_reverse_sequence_batch_major(self):
         x_val = np.array([[[1, 2, 3], [4, 5, 6], [0, 0, 0]],
                           [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                           [[1, 2, 3], [0, 0, 0], [0, 0, 0]]],
                          dtype=np.float32)
         x = tf.placeholder(tf.float32, [None, 3, 3], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=1, batch_axis=0, seq_lengths=[2, 3, 1])
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
         tf.reset_default_graph()
 
         x_val = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3],
@@ -1706,70 +1704,45 @@ def _test_reverse_sequence_batch_major(self, extra_opset=None):
         x = tf.placeholder(tf.float32, [None, 3], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=1, batch_axis=0, seq_lengths=[3] * 9)
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
         tf.reset_default_graph()
 
         x_val_shape = [5, 5, 7, 8, 9]
         x_val = np.random.randint(0, 100, x_val_shape).astype(np.float32)
         x = tf.placeholder(tf.float32, [None, 5, 7, 8, 9], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=1, batch_axis=0, seq_lengths=[5, 5, 5, 5, 5])
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
-
-    def _test_reverse_sequence_time_major(self, extra_opset=None):
-        process_args = {}
-        if extra_opset is not None:
-            process_args["extra_opset"] = [extra_opset]
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
+    @check_opset_min_version(8, "Scan")
+    @skip_opset(9, "ReverseSequence")
+    def test_reverse_sequence_time_major(self):
         x_val = np.array([[[1, 2, 3], [1, 2, 3], [1, 2, 3]],
                           [[4, 5, 6], [4, 5, 6], [0, 0, 0]],
-                          [[0, 0, 0], [7, 8, 9], [0, 0, 0]]
-                          ],
+                          [[0, 0, 0], [7, 8, 9], [0, 0, 0]]],
                          dtype=np.float32)
         x = tf.placeholder(tf.float32, [3, None, 3], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=0, batch_axis=1, seq_lengths=[2, 3, 1])
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
         tf.reset_default_graph()
 
         x_val = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3],
                           [4, 5, 6], [4, 5, 6], [1, 1, 1],
-                          [0, 0, 0], [7, 8, 9], [0, 0, 0]
-                          ],
+                          [0, 0, 0], [7, 8, 9], [0, 0, 0]],
                          dtype=np.float32)
         x = tf.placeholder(tf.float32, [9, None], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=0, batch_axis=1, seq_lengths=[9, 9, 9])
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
         tf.reset_default_graph()
 
         x_val_shape = [5, 5, 7, 8, 9]
         x_val = np.random.randint(0, 100, x_val_shape).astype(np.float32)
         x = tf.placeholder(tf.float32, [5, None, 7, 8, 9], name=_TFINPUT)
         x_ = tf.reverse_sequence(x, seq_axis=0, batch_axis=1, seq_lengths=[5, 5, 5, 5, 5])
         _ = tf.identity(x_, name=_TFOUTPUT)
-        self._run_test_case([_OUTPUT], {_INPUT: x_val}, process_args=process_args)
-
-    @check_opset_min_version(8, "Scan")
-    @skip_opset(9, "ReverseSequence")
-    def test_reverse_sequence_batch_major(self):
-        self._test_reverse_sequence_batch_major()
-
-    @check_opset_min_version(8, "Scan")
-    @skip_opset(9, "ReverseSequence")
-    def test_reverse_sequence_time_major(self):
-        self._test_reverse_sequence_time_major()
-
-    # only support onnxruntime with version larger than 0.4.0
-    @test_ms_domain()
-    @check_onnxruntime_min_version("0.4.0")
-    def test_ms_reverse_sequence_batch_major(self, extra_opset):
-        self._test_reverse_sequence_batch_major(extra_opset)
-
-    @test_ms_domain()
-    @check_onnxruntime_min_version("0.4.0")
-    def test_ms_reverse_sequence_time_major(self, extra_opset):
-        self._test_reverse_sequence_time_major(extra_opset)
+        self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     @check_opset_min_version(8, "where")
     def test_where(self):

tf2onnx/custom_opsets/ms.py

@@ -36,41 +36,3 @@ def version_1(cls, ctx, node, **kwargs):
         utils.make_sure(dtype is not None, "Tidx of %s is None", node.name)
         ctx.remove_node(node.name)
         make_range(ctx, node.input[0], node.input[1], node.input[2], node.output[0], node.name, shape, dtype)
-
-
-@tf_op("ReverseSequence", domain=constants.MICROSOFT_DOMAIN)
-class ReverseSequence:
-    @classmethod
-    def version_1(cls, ctx, node, **kwargs):
-        """ReverseSequence"""
-        # T output = ReverseSequence(T input, int32|int64 seq_lengths, @int seq_dim, @int batch_dim)
-        # T output = ReverseSequence(T input, int32 seqence_lens, @int time_axis, @int batch_axis)
-        seq_dim = node.get_attr("seq_dim")
-        utils.make_sure(seq_dim is not None, "sequence dim must be given in {}".format(node.name))
-        seq_dim = seq_dim.i
-        batch_dim = node.get_attr("batch_dim")
-        if batch_dim is not None:
-            batch_dim = batch_dim.i
-        else:
-            batch_dim = 0
-
-        output_dtypes = node.output_dtypes
-        output_shapes = node.output_shapes
-        ctx.remove_node(node.name)
-        node = ctx.make_node(
-            "ReverseSequence",
-            node.input,
-            outputs=node.output,
-            shapes=output_shapes,
-            dtypes=output_dtypes,
-            domain=constants.MICROSOFT_DOMAIN,
-            attr={"time_axis": seq_dim, "batch_axis": batch_dim}
-        )
-
-        seq_len_dtype = ctx.get_dtype(node.input[1])
-        utils.make_sure(seq_len_dtype is not None, "dtype of {} is None".format(node.input[1]))
-        target_dtype = TensorProto.INT32
-        if seq_len_dtype != target_dtype:
-            cast_node = ctx.insert_new_node_on_input(node, "Cast", node.input[1], to=target_dtype)
-            ctx.copy_shape(cast_node.input[0], cast_node.output[0])
-            ctx.set_dtype(cast_node.output[0], target_dtype)

tf2onnx/onnx_opset/controlflow.py

@@ -13,16 +13,14 @@
 
 import numpy as np
 
-from onnx import onnx_pb
 from onnx.onnx_pb import TensorProto
 from tf2onnx import utils
-from tf2onnx.onnx_opset.nn import spatial_map
 from tf2onnx.handler import tf_op
 from tf2onnx.utils import make_sure
 
-
 logger = logging.getLogger(__name__)
 
+
 # pylint: disable=unused-argument,missing-docstring
 
 def get_inputs_for_current_iteration(g, input_id, iter_index):
@@ -241,78 +239,6 @@ def version_7(cls, ctx, node, **kwargs):
         pass
 
 
-@tf_op("ReverseSequence")
-class ReverseSequence:
-    @classmethod
-    def version_8(cls, ctx, node, **kwargs):
-        # T output = ReverseSequence(T input, int32|int64 seq_lengths, @int seq_dim, @int batch_dim)
-        # T output = Scan(int64 sequence_lens, variadic initial_state_and_scan_inputs, @graph body,
-        #                 @ints directions,@int num_scan_inputs)
-        seq_dim = node.get_attr("seq_dim")
-        batch_dim = node.get_attr("batch_dim")
-        batch_major = seq_dim.i == 1 and (batch_dim or batch_dim.i == 0)
-        time_major = batch_dim.i == 1 and (seq_dim or seq_dim.i == 0)
-        perm_val = None
-
-        if not batch_major and not time_major:
-            error_msg = "unsupported attributes, seq_dim:{}, batch_dim:{}".format(seq_dim, batch_dim)
-            raise ValueError(error_msg)
-
-        if time_major:
-            old_shape = ctx.get_shape(node.input[0])
-            old_dtype = ctx.get_dtype(node.input[0])
-            perm_val = [1, 0]
-            rank = len(old_shape)
-            utils.make_sure(rank >= 2, "rank of reverse_sequence input {} is at least 2".format(node.input[0]))
-            perm_val += list(range(2, rank))
-            trans_node = ctx.insert_new_node_on_input(node, "Transpose", node.input[0], perm=perm_val)
-            new_shape = spatial_map(old_shape, perm_val)
-            ctx.set_shape(trans_node.output[0], new_shape)
-            ctx.set_dtype(trans_node.output[0], old_dtype)
-
-        # handle batch_major input
-        node.type = "Scan"
-        node.set_attr("num_scan_inputs", 1)
-        input_dtype = ctx.get_dtype(node.input[0])
-        input_shape = ctx.get_shape(node.input[0])
-
-        g = ctx.create_new_graph_with_same_config()
-        g.parent_graph = ctx
-        g.add_graph_input('X', input_dtype, input_shape[2:])
-        g.make_node('Identity', ['X'], outputs=['Y'])
-        g.add_graph_output('Y', input_dtype, input_shape[2:])
-
-        node.set_body_graph_as_attr("body", g)
-        node.set_attr("directions", [1])  # reverse the scan input
-
-        seq_len_dtype = ctx.get_dtype(node.input[1])
-        if seq_len_dtype != onnx_pb.TensorProto.INT64:
-            cast_node = ctx.insert_new_node_on_input(node, "Cast", node.input[1])
-            cast_node.set_attr("to", onnx_pb.TensorProto.INT64)
-            ctx.set_dtype(cast_node.output[0], onnx_pb.TensorProto.INT64)
-            ctx.copy_shape(node.input[1], cast_node.output[0])
-
-        if time_major:
-            # get back to time_major
-            op_name = utils.make_name(node.name)
-            trans_back_node = ctx.insert_new_node_on_output("Transpose", node.output[0],
-                                                            name=op_name, perm=perm_val)
-            ctx.copy_dtype(node.output[0], trans_back_node.output[0])
-
-        tmp = node.input[0]
-        node.input[0] = node.input[1]
-        node.input[1] = tmp
-
-    @classmethod
-    def version_9(cls, ctx, node, **kwargs):
-        # T output = ReverseSequence(T input, int32|int64 seq_lengths, @int seq_dim, @int batch_dim)
-        # we cannot easily construct reverse_sequence equivalence in opset 9, so we will not support it
-        # here. Actually using loops to do that is kind of meaningless since there will be performance
-        # issue there for sure.
-        raise NotImplementedError("ReverseSequence is not supported to convert in OPSET 9,"
-                                  " if possible please try using OPSET 8 instead.")
-
-
 @tf_op("Range")
 class Range:
     @classmethod