[Lod][fluid_ops] Remove recursive_sequence_lengths in tests (#69381)

* Fix

* Fix

* Fix

Author: co63oc

test/book/notest_understand_sentiment.py

@@ -191,7 +191,6 @@ def infer(word_dict, use_cuda, save_dirname=None):
             fetch_list=fetch_targets,
             return_numpy=False,
         )
-        print(results[0].recursive_sequence_lengths())
         np_data = np.array(results[0])
         print("Inference Shape: ", np_data.shape)
         print("Inference results: ", np_data)

test/deprecated/legacy_test/test_weight_normalization_deprecated.py

@@ -114,8 +114,6 @@ def set_inputs(self, place):
         for desc in self.data_desc:
             tensor = base.Tensor()
             tensor.set(self.data[desc[0]][0], place)
-            if self.data[desc[0]][1]:
-                tensor.set_recursive_sequence_lengths(self.data[desc[0]][1])
             self.inputs[desc[0]] = tensor
 
     def weight_normalize(self):

test/legacy_test/test_batch_norm_op.py

@@ -191,7 +191,6 @@ def create_or_get_tensor(scope, var_name, var, place):
     tensor = scope.var(var_name).get_tensor()
     if var is not None:
         assert isinstance(var, np.ndarray)
-        tensor.set_recursive_sequence_lengths([])
         tensor.set(var, place)
     return tensor
 

test/legacy_test/test_data_feeder.py

@@ -34,8 +34,6 @@ def test_lod_level_0_converter(self):
 
             self.assertEqual(result['image'].shape(), [2, 1, 28, 28])
             self.assertEqual(result['label'].shape(), [2, 1])
-            self.assertEqual(result['image'].recursive_sequence_lengths(), [])
-            self.assertEqual(result['label'].recursive_sequence_lengths(), [])
 
             try:
                 result = feeder.feed([([0] * 783, [9]), ([1] * 783, [1])])
@@ -66,16 +64,6 @@ def test_lod_level_1_converter(self):
 
             self.assertEqual(result['sentences'].shape(), [9, 1])
             self.assertEqual(result['label'].shape(), [3, 1])
-            if paddle.framework.use_pir_api():
-                self.assertEqual(
-                    result['sentences'].recursive_sequence_lengths(), []
-                )
-            else:
-                self.assertEqual(
-                    result['sentences'].recursive_sequence_lengths(),
-                    [[3, 2, 4]],
-                )
-            self.assertEqual(result['label'].recursive_sequence_lengths(), [])
 
     def test_lod_level_2_converter(self):
         with paddle.static.program_guard(
@@ -100,17 +88,6 @@ def test_lod_level_2_converter(self):
 
             self.assertEqual(result['paragraphs'].shape(), [9, 1])
             self.assertEqual(result['label'].shape(), [2, 1])
-            if paddle.framework.use_pir_api():
-                self.assertEqual(
-                    result['paragraphs'].recursive_sequence_lengths(),
-                    [],
-                )
-            else:
-                self.assertEqual(
-                    result['paragraphs'].recursive_sequence_lengths(),
-                    [[2, 1], [3, 2, 4]],
-                )
-            self.assertEqual(result['label'].recursive_sequence_lengths(), [])
 
     def test_errors(self):
         def pir_mode_not_supported_str_feed():

test/legacy_test/test_feed_fetch_method.py

@@ -35,10 +35,6 @@ def test_feed_fetch(self):
         output.append(input_tensor)
         output_tensor = core.get_fetch_variable(scope, "fetch", 0)
 
-        output_lod = output_tensor.recursive_sequence_lengths()
-        self.assertEqual(2, output_lod[0][0])
-        self.assertEqual(2, output_lod[0][1])
-
         output_array = np.array(output_tensor)
         self.assertEqual(3, output_array[0, 0, 0])
         self.assertEqual(10, output_array[3, 3, 5])

test/legacy_test/test_lod_tensor.py

@@ -14,182 +14,5 @@
 
 import unittest
 
-import numpy as np
-
-import paddle
-from paddle import base
-from paddle.base import core
-from paddle.base.lod_tensor import (
-    create_lod_tensor,
-    create_random_int_lodtensor,
-)
-
-
-class TestLoDTensor(unittest.TestCase):
-    def test_pybind_recursive_seq_lens(self):
-        tensor = base.DenseTensor()
-        recursive_seq_lens = []
-        tensor.set_recursive_sequence_lengths(recursive_seq_lens)
-        recursive_seq_lens = [[], [1], [3]]
-        self.assertRaises(
-            Exception, tensor.set_recursive_sequence_lengths, recursive_seq_lens
-        )
-        recursive_seq_lens = [[0], [2], [3]]
-        self.assertRaises(
-            Exception, tensor.set_recursive_sequence_lengths, recursive_seq_lens
-        )
-
-        recursive_seq_lens = [[1, 2, 3]]
-        tensor.set_recursive_sequence_lengths(recursive_seq_lens)
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), recursive_seq_lens
-        )
-        tensor.set(np.random.random([6, 1]), base.CPUPlace())
-        self.assertTrue(tensor.has_valid_recursive_sequence_lengths())
-        tensor.set(np.random.random([9, 1]), base.CPUPlace())
-        self.assertFalse(tensor.has_valid_recursive_sequence_lengths())
-
-        # Each level's sum should be equal to the number of items in the next level
-        # Moreover, last level's sum should be equal to the tensor height
-        recursive_seq_lens = [[2, 3], [1, 3, 1, 2, 2]]
-        tensor.set_recursive_sequence_lengths(recursive_seq_lens)
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), recursive_seq_lens
-        )
-        tensor.set(np.random.random([8, 1]), base.CPUPlace())
-        self.assertFalse(tensor.has_valid_recursive_sequence_lengths())
-        recursive_seq_lens = [[2, 3], [1, 3, 1, 2, 1]]
-        tensor.set_recursive_sequence_lengths(recursive_seq_lens)
-        self.assertTrue(tensor.has_valid_recursive_sequence_lengths())
-        tensor.set(np.random.random([9, 1]), base.CPUPlace())
-        self.assertFalse(tensor.has_valid_recursive_sequence_lengths())
-
-    def test_create_lod_tensor(self):
-        # Create DenseTensor from a list
-        data = [
-            [np.int64(1), np.int64(2), np.int64(3)],
-            [np.int64(3), np.int64(4)],
-        ]
-        wrong_recursive_seq_lens = [[2, 2]]
-        correct_recursive_seq_lens = [[3, 2]]
-        self.assertRaises(
-            AssertionError,
-            create_lod_tensor,
-            data,
-            wrong_recursive_seq_lens,
-            base.CPUPlace(),
-        )
-        tensor = create_lod_tensor(
-            data, correct_recursive_seq_lens, base.CPUPlace()
-        )
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), correct_recursive_seq_lens
-        )
-        self.assertEqual(
-            tensor._dtype(), paddle.base.core.VarDesc.VarType.INT64
-        )
-        self.assertEqual(tensor.shape(), [5, 1])
-        np.testing.assert_array_equal(
-            np.array(tensor),
-            np.array([1, 2, 3, 3, 4]).reshape(tensor.shape()).astype('int64'),
-        )
-
-        # Create DenseTensor from numpy array
-        data = np.random.random([10, 1]).astype('float64')
-        recursive_seq_lens = [[2, 1], [3, 3, 4]]
-        tensor = create_lod_tensor(data, recursive_seq_lens, base.CPUPlace())
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), recursive_seq_lens
-        )
-        self.assertEqual(tensor._dtype(), paddle.base.core.VarDesc.VarType.FP64)
-        self.assertEqual(tensor.shape(), [10, 1])
-        np.testing.assert_array_equal(np.array(tensor), data)
-
-        # Create DenseTensor from another DenseTensor, they are differnt instances
-        new_recursive_seq_lens = [[2, 2, 1], [1, 2, 2, 3, 2]]
-        new_tensor = create_lod_tensor(
-            tensor, new_recursive_seq_lens, base.CPUPlace()
-        )
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), recursive_seq_lens
-        )
-        self.assertEqual(
-            new_tensor.recursive_sequence_lengths(), new_recursive_seq_lens
-        )
-
-    def test_create_random_int_lodtensor(self):
-        # The shape of a word, commonly used in speech and NLP problem, is [1]
-        shape = [1]
-        recursive_seq_lens = [[2, 3, 5]]
-        dict_size = 10000
-        low = 0
-        high = dict_size - 1
-        tensor = create_random_int_lodtensor(
-            recursive_seq_lens, shape, base.CPUPlace(), low, high
-        )
-        self.assertEqual(
-            tensor.recursive_sequence_lengths(), recursive_seq_lens
-        )
-        self.assertEqual(tensor.shape(), [10, 1])
-
-    def test_print_lodtensor(self):
-        shape = [1]
-        recursive_seq_lens = [[2, 3, 5]]
-        dict_size = 100
-        low = 0
-        high = dict_size - 1
-        tensor = create_random_int_lodtensor(
-            recursive_seq_lens, shape, base.CPUPlace(), low, high
-        )
-        print(tensor)
-        self.assertTrue(isinstance(str(tensor), str))
-
-        if core.is_compiled_with_cuda():
-            gtensor = create_random_int_lodtensor(
-                recursive_seq_lens, shape, base.CUDAPlace(0), low, high
-            )
-            print(gtensor)
-            self.assertTrue(isinstance(str(gtensor), str))
-
-    def test_dlpack_support(self):
-        tensor = base.create_lod_tensor(
-            np.array([[1], [2], [3], [4]]).astype('int'),
-            [[1, 3]],
-            base.CPUPlace(),
-        )
-        dltensor = tensor._to_dlpack()
-        tensor_from_dlpack = base.core.from_dlpack(dltensor)
-        self.assertTrue(isinstance(tensor_from_dlpack, base.core.DenseTensor))
-        np.testing.assert_array_equal(
-            np.array(tensor_from_dlpack),
-            np.array([[1], [2], [3], [4]]).astype('int'),
-        )
-        # when build with cuda
-        if core.is_compiled_with_cuda():
-            gtensor = base.create_lod_tensor(
-                np.array([[1], [2], [3], [4]]).astype('int'),
-                [[1, 3]],
-                base.CUDAPlace(0),
-            )
-            gdltensor = gtensor._to_dlpack()
-            gtensor_from_dlpack = base.core.from_dlpack(gdltensor)
-            self.assertTrue(
-                isinstance(gtensor_from_dlpack, base.core.DenseTensor)
-            )
-            np.testing.assert_array_equal(
-                np.array(gtensor_from_dlpack),
-                np.array([[1], [2], [3], [4]]).astype('int'),
-            )
-
-    def test_as_type(self):
-        tensor = base.create_lod_tensor(
-            np.array([[1], [2], [3], [4]]).astype('int'),
-            [[1, 3]],
-            base.CPUPlace(),
-        )
-        fp32_tensor = tensor._as_type(paddle.base.core.VarDesc.VarType.FP32)
-        print(fp32_tensor)
-
-
 if __name__ == '__main__':
     unittest.main()

test/legacy_test/test_lod_tensor_array.py

@@ -30,23 +30,19 @@ def test_get_set(self):
         for i in range(10):
             t = core.DenseTensor()
             t.set(np.array([i], dtype='float32'), cpu)
-            t.set_recursive_sequence_lengths([[1]])
             tensor_array.append(t)
 
         self.assertEqual(10, len(tensor_array))
 
         for i in range(10):
             t = tensor_array[i]
             self.assertEqual(np.array(t), np.array([i], dtype='float32'))
-            self.assertEqual([[1]], t.recursive_sequence_lengths())
 
             t = core.DenseTensor()
             t.set(np.array([i + 10], dtype='float32'), cpu)
-            t.set_recursive_sequence_lengths([[1]])
             tensor_array[i] = t
             t = tensor_array[i]
             self.assertEqual(np.array(t), np.array([i + 10], dtype='float32'))
-            self.assertEqual([[1]], t.recursive_sequence_lengths())
 
 
 class TestCreateArray(unittest.TestCase):

test/legacy_test/test_print_op.py

@@ -35,7 +35,6 @@ def setUp(self):
         self.x_tensor = base.core.DenseTensor()
         tensor_np = np.random.random(size=(2, 3)).astype(self.dtype)
         self.x_tensor.set(tensor_np, self.place)
-        self.x_tensor.set_recursive_sequence_lengths([[1, 1]])
 
     def build_network(self, only_forward, **kargs):
         x = paddle.static.data(
@@ -140,7 +139,6 @@ def setUp(self):
         self.x_tensor = base.core.DenseTensor()
         tensor_np = np.random.random(size=(2, 3)).astype(self.dtype)
         self.x_tensor.set(tensor_np, self.place)
-        self.x_tensor.set_recursive_sequence_lengths([[1, 1]])
 
 
 @unittest.skipIf(
@@ -153,7 +151,6 @@ def setUp(self):
         self.x_tensor = base.core.DenseTensor()
         tensor_np = np.random.random(size=(2, 3)).astype(self.dtype)
         self.x_tensor.set(tensor_np, self.place)
-        self.x_tensor.set_recursive_sequence_lengths([[1, 1]])
 
 
 @unittest.skipIf(
@@ -166,7 +163,6 @@ def setUp(self):
         self.x_tensor = base.core.DenseTensor()
         tensor_np = convert_float_to_uint16(np.random.random(size=(2, 3)))
         self.x_tensor.set(tensor_np, self.place)
-        self.x_tensor.set_recursive_sequence_lengths([[1, 1]])
 
 
 class TestPrintOpBackward(unittest.TestCase):

test/legacy_test/test_tensor.py

@@ -173,15 +173,10 @@ def test_int_lod_tensor(self):
         array[0, 0, 0] = 3
         array[3, 3, 5] = 10
         lod_tensor.set(array, place)
-        lod_tensor.set_recursive_sequence_lengths([[2, 2]])
 
         lod_v = np.array(lod_tensor)
         self.assertTrue(np.all(array == lod_v))
 
-        lod = lod_tensor.recursive_sequence_lengths()
-        self.assertEqual(2, lod[0][0])
-        self.assertEqual(2, lod[0][1])
-
     def test_float_lod_tensor(self):
         place = core.CPUPlace()
         scope = core.Scope()
@@ -200,50 +195,6 @@ def test_float_lod_tensor(self):
         lod_v = np.array(lod_tensor)
         self.assertAlmostEqual(1.0, lod_v[0, 0, 0, 0])
         self.assertAlmostEqual(2.0, lod_v[0, 0, 0, 1])
-        self.assertEqual(len(lod_tensor.recursive_sequence_lengths()), 0)
-
-        lod_py = [[2, 1], [1, 2, 2]]
-        lod_tensor.set_recursive_sequence_lengths(lod_py)
-        lod = lod_tensor.recursive_sequence_lengths()
-        self.assertListEqual(lod_py, lod)
-
-    def test_lod_tensor_init(self):
-        place = core.CPUPlace()
-        lod_py = [[2, 1], [1, 2, 2]]
-        lod_tensor = core.DenseTensor()
-
-        lod_tensor._set_dims([5, 2, 3, 4])
-        lod_tensor.set_recursive_sequence_lengths(lod_py)
-        lod_tensor._alloc_float(place)
-        tensor_array = np.array(lod_tensor)
-        tensor_array[0, 0, 0, 0] = 1.0
-        tensor_array[0, 0, 0, 1] = 2.0
-        lod_tensor.set(tensor_array, place)
-
-        lod_v = np.array(lod_tensor)
-        self.assertAlmostEqual(1.0, lod_v[0, 0, 0, 0])
-        self.assertAlmostEqual(2.0, lod_v[0, 0, 0, 1])
-        self.assertListEqual(lod_py, lod_tensor.recursive_sequence_lengths())
-
-    def test_lod_tensor_gpu_init(self):
-        if not core.is_compiled_with_cuda():
-            return
-        place = core.CUDAPlace(0)
-        lod_py = [[2, 1], [1, 2, 2]]
-        lod_tensor = core.DenseTensor()
-
-        lod_tensor._set_dims([5, 2, 3, 4])
-        lod_tensor.set_recursive_sequence_lengths(lod_py)
-        lod_tensor._alloc_float(place)
-        tensor_array = np.array(lod_tensor)
-        tensor_array[0, 0, 0, 0] = 1.0
-        tensor_array[0, 0, 0, 1] = 2.0
-        lod_tensor.set(tensor_array, place)
-
-        lod_v = np.array(lod_tensor)
-        self.assertAlmostEqual(1.0, lod_v[0, 0, 0, 0])
-        self.assertAlmostEqual(2.0, lod_v[0, 0, 0, 1])
-        self.assertListEqual(lod_py, lod_tensor.recursive_sequence_lengths())
 
     def test_empty_tensor(self):
         place = core.CPUPlace()