[Lod][fluid_ops]recursive_sequence_lengths (#69380)

co63oc · web-flow · commit dcbea30d3b31 · 2024-11-19T09:32:23.000+08:00
* Fix

* Fix
diff --git a/paddle/fluid/pybind/tensor.cc b/paddle/fluid/pybind/tensor.cc
@@ -633,63 +633,6 @@ void BindTensor(pybind11::module &m) {  // NOLINT
                     >>> print(t.lod())
                     [[0, 2, 5]]
            )DOC")
-      // Set above comments of set_lod.
-      .def(
-          "recursive_sequence_lengths",
-          [](phi::DenseTensor &self) -> std::vector<std::vector<size_t>> {
-            // output the length-based lod info
-            LoD lod = phi::ConvertToLengthBasedLoD(self.lod());
-            std::vector<std::vector<size_t>> new_lod;
-            new_lod.reserve(lod.size());
-            std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
-            return new_lod;
-          },
-          R"DOC(
-           Return the recursive sequence lengths corresponding to of the LodD
-           of the Tensor.
-
-           Returns:
-                list[list[int]]: The recursive sequence lengths.
-
-           Examples:
-                .. code-block:: python
-
-                    >>> import paddle
-                    >>> import numpy as np
-
-                    >>> t = paddle.framework.core.Tensor()
-                    >>> t.set(np.ndarray([5, 30]), paddle.CPUPlace())
-                    >>> t.set_recursive_sequence_lengths([[2, 3]])
-                    >>> print(t.recursive_sequence_lengths())
-                    [[2, 3]]
-           )DOC")
-      .def(
-          "has_valid_recursive_sequence_lengths",
-          [](phi::DenseTensor &self) -> bool {
-            // Check that the lod info is valid and match the outermost
-            // dimension of the Tensor data
-            return CheckLoD(
-                self.lod(),
-                static_cast<int>(common::vectorize(self.dims()).front()));
-          },
-          R"DOC(
-           Check whether the LoD of the Tensor is valid.
-
-           Returns:
-               bool: Whether the LoD is valid.
-
-           Examples:
-                .. code-block:: python
-
-                    >>> import paddle
-                    >>> import numpy as np
-
-                    >>> t = paddle.framework.core.Tensor()
-                    >>> t.set(np.ndarray([5, 30]), paddle.CPUPlace())
-                    >>> t.set_recursive_sequence_lengths([[2, 3]])
-                    >>> print(t.has_valid_recursive_sequence_lengths())
-                    True
-           )DOC")
       .def("_as_type",
            [](const phi::DenseTensor &self,
               paddle::framework::proto::VarType::Type type) {
diff --git a/python/paddle/base/lod_tensor.py b/python/paddle/base/lod_tensor.py
@@ -102,9 +102,6 @@ def create_lod_tensor(data, recursive_seq_lens, place):
         tensor = core.DenseTensor()
         tensor.set(data, place)
         tensor.set_recursive_sequence_lengths(recursive_seq_lens)
-        assert (
-            tensor.has_valid_recursive_sequence_lengths()
-        ), "the provided lod info is invalid"
         return tensor
     else:
         raise TypeError(
diff --git a/test/legacy_test/op_test.py b/test/legacy_test/op_test.py
@@ -2281,10 +2281,6 @@ def _compare_numpy(self, name, actual_np, expect_np):
                     ),
                 )
 
-            def _compare_list(self, name, actual, expect):
-                """if expect is a tuple, we need to compare list."""
-                raise NotImplementedError("base class, not implement!")
-
             def compare_single_output_with_expect(self, name, expect):
                 actual, actual_np = self.find_actual_value(name)
                 # expect_np = expect[0] if isinstance(expect, tuple) else expect
@@ -2301,8 +2297,6 @@ def compare_single_output_with_expect(self, name, expect):
                 )
                 # modify there for fp32 check
                 self._compare_numpy(name, actual_np, expect_np)
-                if isinstance(expect, (tuple, list)):
-                    self._compare_list(name, actual, expect)
 
             def compare_outputs_with_expects(self):
                 for out_name, out_dup in Operator.get_op_outputs(self.op_type):
@@ -2388,14 +2382,6 @@ def convert_uint16_to_float_ifneed(self, actual_np, expect_np):
                     atol = max(atol, 0.03)
                 return actual_np, expect_np
 
-            def _compare_list(self, name, actual, expect):
-                """if expect is a tuple, we need to compare list."""
-                self.op_test.assertListEqual(
-                    actual.recursive_sequence_lengths(),
-                    expect[1],
-                    "Output (" + name + ") has different lod at " + str(place),
-                )
-
         class DygraphChecker(Checker):
             def init(self):
                 self.checker_name = "dygraph checker"
@@ -2482,23 +2468,6 @@ def find_expect_value(self, name):
                     )
                     return imperative_expect, imperative_expect_t
 
-            def _compare_list(self, name, actual, expect):
-                """if expect is a tuple, we need to compare list."""
-                with base.dygraph.base.guard(place=place):
-                    self.op_test.assertListEqual(
-                        actual.value()
-                        .get_tensor()
-                        .recursive_sequence_lengths(),
-                        expect[1],
-                        "Operator ("
-                        + self.op_type
-                        + ") Output ("
-                        + name
-                        + ") has different lod at "
-                        + str(place)
-                        + " in dygraph mode",
-                    )
-
             def _is_skip_name(self, name):
                 # if in final state and kernel signature don't have name, then skip it.
                 if (
@@ -2623,23 +2592,6 @@ def find_expect_value(self, target_name):
                     expect_t = np.array(expect)
                     return expect, expect_t
 
-            def _compare_list(self, name, actual, expect):
-                """if expect is a tuple, we need to compare list."""
-                with paddle.pir.core.program_guard(place=place):
-                    self.op_test.assertListEqual(
-                        actual.value()
-                        .get_tensor()
-                        .recursive_sequence_lengths(),
-                        expect[1],
-                        "Operator ("
-                        + self.op_type
-                        + ") Output ("
-                        + name
-                        + ") has different lod at "
-                        + str(place)
-                        + " in dygraph mode",
-                    )
-
             def _is_skip_name(self, name):
                 # if in final state and kernel signature don't have name, then skip it.
                 if (
