pair bi-rnn by name hidden_size and seq_len

Author: lucienwang1009

tests/test_gru.py

@@ -482,22 +482,67 @@ def test_dynamic_bidirectional_but_one_gru_and_state_consumed_only(self):
         self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
                            graph_validator=lambda g: check_gru_count(g, 1))
 
-    def test_dynamic_multi_bigru_with_same_input(self):
+    def test_dynamic_bigru_unknown_batch_size(self):
         units = 5
-        batch_size = 1
+        batch_size = 6
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+
+        x = tf.placeholder(tf.float32, [None, 3, 2], name="input_1")
+
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
+        _, cell_state = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            dtype=tf.float32,
+        )
+
+        _ = tf.identity(cell_state, name="cell_state")
+
+        feed_dict = {"input_1:0": x_val}
+        input_names_with_port = ["input_1:0"]
+        output_names_with_port = ["cell_state:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-06,
+                           graph_validator=lambda g: check_gru_count(g, 1))
+
+    def test_dynamic_bigru_outputs_partially_consumed(self):
+        units = 5
+        batch_size = 6
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+
+        x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
+
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
+        (output_fw, _), (_, state_bw) = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            dtype=tf.float32)
+
+        _ = tf.identity(output_fw, name="output")
+        _ = tf.identity(state_bw, name="cell_state")
+
+        feed_dict = {"input_1:0": x_val}
+        input_names_with_port = ["input_1:0"]
+        output_names_with_port = ["output:0", "cell_state:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-06,
+                           graph_validator=lambda g: check_gru_count(g, 1))
+
+    def test_dynamic_multi_bigru_with_same_input_hidden_size(self):
+        units = 5
+        batch_size = 10
         x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
         x_val = np.stack([x_val] * batch_size)
 
         x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
-        initializer = init_ops.constant_initializer(0.5)
 
         # bigru, no scope
-        cell1 = rnn.GRUCell(
-            units,
-            kernel_initializer=initializer)
-        cell2 = rnn.GRUCell(
-            units,
-            kernel_initializer=initializer)
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
         outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
             cell1,
             cell2,
@@ -507,12 +552,8 @@ def test_dynamic_multi_bigru_with_same_input(self):
         )
 
         units = 10
-        cell1 = rnn.GRUCell(
-            units,
-            kernel_initializer=initializer)
-        cell2 = rnn.GRUCell(
-            units,
-            kernel_initializer=initializer)
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
         outputs_2, cell_state_2 = tf.nn.bidirectional_dynamic_rnn(
             cell1,
             cell2,
@@ -532,6 +573,52 @@ def test_dynamic_multi_bigru_with_same_input(self):
         self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
                            graph_validator=lambda g: check_gru_count(g, 2))
 
+    def test_dynamic_multi_bigru_with_same_input_seq_len(self):
+        units = 5
+        batch_size = 10
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+        seq_len_val = np.array([3], dtype=np.int32)
+
+        x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
+
+        y1 = tf.placeholder(tf.int32, seq_len_val.shape, name="input_2")
+        seq_len1 = tf.tile(y1, [batch_size])
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
+        outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            sequence_length=seq_len1,
+            dtype=tf.float32,
+            scope="bigru_1"
+        )
+
+        y2 = tf.placeholder(tf.int32, seq_len_val.shape, name="input_3")
+        seq_len2 = tf.tile(y2, [batch_size])
+        cell1 = rnn.GRUCell(units)
+        cell2 = rnn.GRUCell(units)
+        outputs_2, cell_state_2 = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            sequence_length=seq_len2,
+            dtype=tf.float32,
+            scope="bigru_2"
+        )
+
+        _ = tf.identity(outputs_1, name="output_1")
+        _ = tf.identity(cell_state_1, name="cell_state_1")
+        _ = tf.identity(outputs_2, name="output_2")
+        _ = tf.identity(cell_state_2, name="cell_state_2")
+
+        feed_dict = {"input_1:0": x_val, "input_2:0": seq_len_val, "input_3:0": seq_len_val}
+        input_names_with_port = ["input_1:0", "input_2:0", "input_3:0"]
+        output_names_with_port = ["output_1:0", "cell_state_1:0", "output_2:0", "cell_state_2:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
+                           graph_validator=lambda g: check_gru_count(g, 2))
+
 
 if __name__ == '__main__':
     unittest_main()

tests/test_grublock.py

@@ -447,47 +447,6 @@ def test_dynamic_bidirectional_but_one_gru_and_state_consumed_only(self):
         self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
                            graph_validator=lambda g: check_gru_count(g, 1))
 
-    def test_dynamic_multi_bigru_with_same_input(self):
-        units = 5
-        batch_size = 1
-        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
-        x_val = np.stack([x_val] * batch_size)
-
-        x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
-
-        # bigru, no scope
-        cell1 = rnn.GRUBlockCell(units)
-        cell2 = rnn.GRUBlockCell(units)
-        outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
-            cell1,
-            cell2,
-            x,
-            dtype=tf.float32,
-            scope="bigru_1"
-        )
-
-        units = 10
-        cell1 = rnn.GRUBlockCell(units)
-        cell2 = rnn.GRUBlockCell(units)
-        outputs_2, cell_state_2 = tf.nn.bidirectional_dynamic_rnn(
-            cell1,
-            cell2,
-            x,
-            dtype=tf.float32,
-            scope="bigru_2"
-        )
-
-        _ = tf.identity(outputs_1, name="output_1")
-        _ = tf.identity(cell_state_1, name="cell_state_1")
-        _ = tf.identity(outputs_2, name="output_2")
-        _ = tf.identity(cell_state_2, name="cell_state_2")
-
-        feed_dict = {"input_1:0": x_val}
-        input_names_with_port = ["input_1:0"]
-        output_names_with_port = ["output_1:0", "cell_state_1:0", "output_2:0", "cell_state_2:0"]
-        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
-                           graph_validator=lambda g: check_gru_count(g, 2))
-
 
 if __name__ == '__main__':
     unittest_main()

tests/test_lstm.py

@@ -554,50 +554,92 @@ def test_dynamic_bilstm_state_consumed_only(self, state_is_tuple=True):
         self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-06,
                            graph_validator=lambda g: check_lstm_count(g, 1))
 
-    def test_dynamic_multi_bilstm_with_same_input_state_is_tuple(self):
-        self.internal_test_dynamic_multi_bilstm_with_same_input(True)
-
-    def test_dynamic_multi_bilstm_with_same_input_state_is_list(self):
-        self.internal_test_dynamic_multi_bilstm_with_same_input(False)
-
-    def internal_test_dynamic_multi_bilstm_with_same_input(self, state_is_tuple):
+    def test_dynamic_bilstm_outputs_partially_consumed(self, state_is_tuple=True):
         units = 5
-        batch_size = 1
+        batch_size = 6
         x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
         x_val = np.stack([x_val] * batch_size)
 
         x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
         initializer = init_ops.constant_initializer(0.5)
 
+        # bilstm, no scope
         cell1 = rnn.LSTMCell(
             units,
             initializer=initializer,
-            state_is_tuple=state_is_tuple
-        )
+            state_is_tuple=state_is_tuple)  # state_is_tuple will impact Pack node (for cell_state)'s usage pattern
         cell2 = rnn.LSTMCell(
             units,
             initializer=initializer,
-            state_is_tuple=state_is_tuple
-        )
-        outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
+            state_is_tuple=state_is_tuple)
+        (output_fw, _), (_, state_bw) = tf.nn.bidirectional_dynamic_rnn(
             cell1,
             cell2,
             x,
-            dtype=tf.float32,
-            scope="bilstm_1"
-        )
+            dtype=tf.float32)
+
+        _ = tf.identity(output_fw, name="output")
+        _ = tf.identity(state_bw, name="cell_state")
+
+        feed_dict = {"input_1:0": x_val}
+        input_names_with_port = ["input_1:0"]
+        output_names_with_port = ["output:0", "cell_state:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-06,
+                           graph_validator=lambda g: check_lstm_count(g, 1))
+
+    def test_dynamic_bilstm_unknown_batch_size(self, state_is_tuple=True):
+        units = 5
+        batch_size = 6
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+
+        x = tf.placeholder(tf.float32, [None, 3, 2], name="input_1")
+        initializer = init_ops.constant_initializer(0.5)
 
-        units = 10
         cell1 = rnn.LSTMCell(
             units,
             initializer=initializer,
-            state_is_tuple=state_is_tuple
-        )
+            state_is_tuple=state_is_tuple)
         cell2 = rnn.LSTMCell(
             units,
             initializer=initializer,
-            state_is_tuple=state_is_tuple
+            state_is_tuple=state_is_tuple)
+        _, cell_state = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            dtype=tf.float32,
+        )
+
+        _ = tf.identity(cell_state, name="cell_state")
+
+        feed_dict = {"input_1:0": x_val}
+        input_names_with_port = ["input_1:0"]
+        output_names_with_port = ["cell_state:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-06,
+                           graph_validator=lambda g: check_lstm_count(g, 1))
+
+    def test_dynamic_multi_bilstm_with_same_input_hidden_size(self):
+        units = 5
+        batch_size = 10
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+
+        x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
+
+        cell1 = rnn.LSTMCell(units)
+        cell2 = rnn.LSTMCell(units)
+        outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            dtype=tf.float32,
+            scope="bilstm_1"
         )
+
+        units = 10
+        cell1 = rnn.LSTMCell(units)
+        cell2 = rnn.LSTMCell(units)
         outputs_2, cell_state_2 = tf.nn.bidirectional_dynamic_rnn(
             cell1,
             cell2,
@@ -617,6 +659,52 @@ def internal_test_dynamic_multi_bilstm_with_same_input(self, state_is_tuple):
         self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
                            graph_validator=lambda g: check_lstm_count(g, 2))
 
+    def test_dynamic_multi_bilstm_with_same_input_seq_len(self):
+        units = 5
+        batch_size = 10
+        x_val = np.array([[1., 1.], [2., 2.], [3., 3.]], dtype=np.float32)
+        x_val = np.stack([x_val] * batch_size)
+        seq_len_val = np.array([3], dtype=np.int32)
+
+        x = tf.placeholder(tf.float32, x_val.shape, name="input_1")
+
+        y1 = tf.placeholder(tf.int32, seq_len_val.shape, name="input_2")
+        seq_len1 = tf.tile(y1, [batch_size])
+        cell1 = rnn.LSTMCell(units)
+        cell2 = rnn.LSTMCell(units)
+        outputs_1, cell_state_1 = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            sequence_length=seq_len1,
+            dtype=tf.float32,
+            scope="bilstm_1"
+        )
+
+        y2 = tf.placeholder(tf.int32, seq_len_val.shape, name="input_3")
+        seq_len2 = tf.tile(y2, [batch_size])
+        cell1 = rnn.LSTMCell(units)
+        cell2 = rnn.LSTMCell(units)
+        outputs_2, cell_state_2 = tf.nn.bidirectional_dynamic_rnn(
+            cell1,
+            cell2,
+            x,
+            sequence_length=seq_len2,
+            dtype=tf.float32,
+            scope="bilstm_2"
+        )
+
+        _ = tf.identity(outputs_1, name="output_1")
+        _ = tf.identity(cell_state_1, name="cell_state_1")
+        _ = tf.identity(outputs_2, name="output_2")
+        _ = tf.identity(cell_state_2, name="cell_state_2")
+
+        feed_dict = {"input_1:0": x_val, "input_2:0": seq_len_val, "input_3:0": seq_len_val}
+        input_names_with_port = ["input_1:0", "input_2:0", "input_3:0"]
+        output_names_with_port = ["output_1:0", "cell_state_1:0", "output_2:0", "cell_state_2:0"]
+        self.run_test_case(feed_dict, input_names_with_port, output_names_with_port, rtol=1e-3, atol=1e-06,
+                           graph_validator=lambda g: check_lstm_count(g, 2))
+
 
 if __name__ == '__main__':
     unittest_main()