Merge pull request #483 from nbcsm/rs10

opset10 - ReverseSequence

Author: nbcsm

tests/test_backend.py

@@ -724,7 +724,6 @@ def test_equal(self):
         _ = tf.identity(mi, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val1, _INPUT1: x_val2})
 
-
     def test_sequeeze_no_axis_specified(self):
         x_val = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32).reshape((2, 2, 1))
         x = tf.placeholder(tf.float32, [2, 2, 1], name=_TFINPUT)
@@ -982,14 +981,14 @@ def test_slice1(self):
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     def test_split(self):
-        x_val = np.linspace(1.0, 5 * 30.0, 5 * 30).astype(np.float32).reshape(5, 30)
+        x_val = np.linspace(1.0, 5 * 30.0, 5 * 30).astype(np.float32).reshape((5, 30))
         x0 = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_, _, _ = tf.split(x0, [4, 15, 11], 1)
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     def test_split_with_more_outputs(self):
-        x_val = np.linspace(1.0, 5 * 30.0, 5 * 30).astype(np.float32).reshape(5, 30)
+        x_val = np.linspace(1.0, 5 * 30.0, 5 * 30).astype(np.float32).reshape((5, 30))
         x0 = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         _, _, _ = tf.split(x0, [4, 15, 11], 1, name="split_test")
         self._run_test_case(["split_test:0", "split_test:1", "split_test:2"], {_INPUT: x_val})
@@ -1418,36 +1417,36 @@ def test_addn(self):
 
     @skip_caffe2_backend("multiple dims not supported")
     def test_strided_slice1(self):
-        x_val = np.arange(3 * 2 * 3).astype("float32").reshape(3, 2, 3)
+        x_val = np.arange(3 * 2 * 3).astype("float32").reshape((3, 2, 3))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = tf.strided_slice(x, [1, 0, 0], [2, 1, 3], [1, 1, 1])
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     def test_strided_slice2(self):
-        x_val = np.arange(3 * 2 * 3).astype("float32").reshape(3, 2, 3)
+        x_val = np.arange(3 * 2 * 3).astype("float32").reshape((3, 2, 3))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = tf.strided_slice(x, [1, 0, 0], [2, 2, 3], [1, 1, 1])
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     def test_strided_slice3(self):
-        x_val = np.arange(3 * 2 * 3).astype("float32").reshape(3, 2, 3)
+        x_val = np.arange(3 * 2 * 3).astype("float32").reshape((3, 2, 3))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = x[1:]
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     def test_strided_slice4(self):
-        x_val = np.arange(3 * 2 * 3).astype("float32").reshape(3, 2, 3)
+        x_val = np.arange(3 * 2 * 3).astype("float32").reshape((3, 2, 3))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = x[:2]
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     @skip_caffe2_backend("multiple dims not supported")
     def test_strided_slice5(self):
-        x_val = np.arange(3 * 2 * 3).astype("float32").reshape(3, 2, 3)
+        x_val = np.arange(3 * 2 * 3).astype("float32").reshape((3, 2, 3))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = x[:2, 0:1, 1:]
         _ = tf.identity(x_, name=_TFOUTPUT)
@@ -1457,15 +1456,15 @@ def test_strided_slice5(self):
     def test_strided_slice6(self):
         # example from here:
         # https://www.tensorflow.org/versions/r1.0/api_docs/cc/class/tensorflow/ops/strided-slice
-        x_val = np.arange(5 * 6).astype("float32").reshape(5, 6)
+        x_val = np.arange(5 * 6).astype("float32").reshape((5, 6))
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = x[2, :]
         _ = tf.identity(x_, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
     @skip_caffe2_backend("multiple dims not supported")
     def test_strided_slice7(self):
-        x_val = np.arange(5 * 6).astype("float32").reshape(5, 6)
+        x_val = np.arange(5 * 6).astype("float32").reshape((5, 6))
 
         x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
         x_ = tf.strided_slice(x, [0, 1], [3, 4], [1, 1], begin_mask=2)
@@ -1684,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],
@@ -1707,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):

tests/test_custom_rnncell.py

@@ -416,11 +416,11 @@ def call(self, inputs, state):
         input_dim = inputs.get_shape()[-1]
         assert input_dim is not None, "input dimension must be defined"
         # W = tf.get_variable(name="W", shape=[input_dim, 3 * self._num_units], dtype=tf.float32)
-        W = np.arange(30.0, dtype=np.float32).reshape(2, 15)
+        W = np.arange(30.0, dtype=np.float32).reshape((2, 15))
         # U = tf.get_variable(name='U', shape=[self._num_units, 3 * self._num_units], dtype=tf.float32)
-        U = np.arange(75.0, dtype=np.float32).reshape(5, 15)
+        U = np.arange(75.0, dtype=np.float32).reshape((5, 15))
         # b = tf.get_variable(name='b', shape=[1, 3 * self._num_units], dtype=tf.float32)
-        b = np.arange(15.0, dtype=np.float32).reshape(1, 15)
+        b = np.arange(15.0, dtype=np.float32).reshape((1, 15))
 
         xw = tf.split(tf.matmul(inputs, W) + b, 3, 1)
         hu = tf.split(tf.matmul(state, U), 3, 1)

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