# Copyright 2015 The TensorFlow 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. # ============================================================================== """Tests for tensorflow.ops.reverse_sequence_op.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from six.moves import xrange # pylint: disable=redefined-builtin from tensorflow.python.framework import constant_op from tensorflow.python.framework import dtypes from tensorflow.python.ops import array_ops from tensorflow.python.ops import gradient_checker from tensorflow.python.platform import test class ReverseSequenceTest(test.TestCase): def _testReverseSequence(self, x, batch_axis, seq_axis, seq_lengths, truth, use_gpu=False, expected_err_re=None): with self.test_session(use_gpu=use_gpu): ans = array_ops.reverse_sequence( x, batch_axis=batch_axis, seq_axis=seq_axis, seq_lengths=seq_lengths) if expected_err_re is None: tf_ans = ans.eval() self.assertAllClose(tf_ans, truth, atol=1e-10) self.assertShapeEqual(truth, ans) else: with self.assertRaisesOpError(expected_err_re): ans.eval() def _testBothReverseSequence(self, x, batch_axis, seq_axis, seq_lengths, truth, expected_err_re=None): self._testReverseSequence(x, batch_axis, seq_axis, seq_lengths, truth, True, expected_err_re) self._testReverseSequence(x, batch_axis, seq_axis, seq_lengths, truth, False, expected_err_re) def _testBasic(self, dtype, len_dtype=np.int64): x = np.asarray( [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]], [[17, 18, 19, 20], [21, 22, 23, 24]]], dtype=dtype) x = x.reshape(3, 2, 4, 1, 1) x = x.transpose([2, 1, 0, 3, 4]) # permute axes 0 <=> 2 # reverse dim 2 up to (0:3, none, 0:4) along dim=0 seq_lengths = np.asarray([3, 0, 4], dtype=len_dtype) truth_orig = np.asarray( [ [[3, 2, 1, 4], [7, 6, 5, 8]], # reverse 0:3 [[9, 10, 11, 12], [13, 14, 15, 16]], # reverse none [[20, 19, 18, 17], [24, 23, 22, 21]] ], # reverse 0:4 (all) dtype=dtype) truth_orig = truth_orig.reshape(3, 2, 4, 1, 1) truth = truth_orig.transpose([2, 1, 0, 3, 4]) # permute axes 0 <=> 2 seq_axis = 0 # permute seq_axis and batch_axis (originally 2 and 0, resp.) batch_axis = 2 self._testBothReverseSequence(x, batch_axis, seq_axis, seq_lengths, truth) def testSeqLengthInt32(self): self._testBasic(np.float32, np.int32) def testFloatBasic(self): self._testBasic(np.float32) def testDoubleBasic(self): self._testBasic(np.float64) def testInt32Basic(self): self._testBasic(np.int32) def testInt64Basic(self): self._testBasic(np.int64) def testComplex64Basic(self): self._testBasic(np.complex64) def testComplex128Basic(self): self._testBasic(np.complex128) def testFloatReverseSequenceGrad(self): x = np.asarray( [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]], [[17, 18, 19, 20], [21, 22, 23, 24]]], dtype=np.float) x = x.reshape(3, 2, 4, 1, 1) x = x.transpose([2, 1, 0, 3, 4]) # transpose axes 0 <=> 2 # reverse dim 0 up to (0:3, none, 0:4) along dim=2 seq_axis = 0 batch_axis = 2 seq_lengths = np.asarray([3, 0, 4], dtype=np.int64) with self.cached_session(): input_t = constant_op.constant(x, shape=x.shape) seq_lengths_t = constant_op.constant(seq_lengths, shape=seq_lengths.shape) reverse_sequence_out = array_ops.reverse_sequence( input_t, batch_axis=batch_axis, seq_axis=seq_axis, seq_lengths=seq_lengths_t) err = gradient_checker.compute_gradient_error( input_t, x.shape, reverse_sequence_out, x.shape, x_init_value=x) print("ReverseSequence gradient error = %g" % err) self.assertLess(err, 1e-8) def testShapeFunctionEdgeCases(self): t = array_ops.reverse_sequence( array_ops.placeholder( dtypes.float32, shape=None), seq_lengths=array_ops.placeholder( dtypes.int64, shape=(32,)), batch_axis=0, seq_axis=1) self.assertIs(t.get_shape().ndims, None) # Batch size mismatched between input and seq_lengths. with self.assertRaises(ValueError): array_ops.reverse_sequence( array_ops.placeholder( dtypes.float32, shape=(32, 2, 3)), seq_lengths=array_ops.placeholder( dtypes.int64, shape=(33,)), seq_axis=3) # seq_axis out of bounds. with self.assertRaisesRegexp(ValueError, "seq_dim must be < input rank"): array_ops.reverse_sequence( array_ops.placeholder( dtypes.float32, shape=(32, 2, 3)), seq_lengths=array_ops.placeholder( dtypes.int64, shape=(32,)), seq_axis=3) # batch_axis out of bounds. with self.assertRaisesRegexp(ValueError, "batch_dim must be < input rank"): array_ops.reverse_sequence( array_ops.placeholder( dtypes.float32, shape=(32, 2, 3)), seq_lengths=array_ops.placeholder( dtypes.int64, shape=(32,)), seq_axis=0, batch_axis=3) with self.cached_session(): inputs = array_ops.placeholder(dtypes.float32, shape=(32, 2, 3)) seq_lengths = array_ops.placeholder(dtypes.int64, shape=(32,)) output = array_ops.reverse_sequence( inputs, seq_lengths=seq_lengths, seq_axis=0) # batch_axis default is 0 with self.assertRaisesOpError("batch_dim == seq_dim"): output.eval(feed_dict={ inputs: np.random.rand(32, 2, 3), seq_lengths: xrange(32) }) if __name__ == "__main__": test.main()