[API-Compat] Resolved merged conflicts, add symbolic shape test.

Author: Enigmatisms

python/paddle/tensor/compat.py

@@ -25,6 +25,7 @@
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
 
     from paddle import Tensor
     from paddle._typing import (
@@ -639,24 +640,35 @@ def min(
         ret = paddle.min(input)
     elif isinstance(dim_or_other, int):
         _check_out_status(out, True)
-        if in_dynamic_mode() and not input.place.is_gpu_place():
-            _min_max_allow_cpu_composite(input)
-            # CPUPlace and other placements are implemented by composition
-            indices = paddle.argmin(input, axis=dim_or_other, keepdim=True)
-            values = paddle.take_along_axis(input, indices, axis=dim_or_other)
-            if keepdim:
-                ret = MinMaxRetType(values=values, indices=indices)
+        if input.ndim:
+            if in_dynamic_mode() and not input.place.is_gpu_place():
+                _min_max_allow_cpu_composite(input)
+                # CPUPlace and other placements are implemented by composition
+
+                indices = paddle.argmin(input, axis=dim_or_other, keepdim=True)
+                values = paddle.take_along_axis(
+                    input, indices, axis=dim_or_other
+                )
+                if keepdim:
+                    ret = MinMaxRetType(values=values, indices=indices)
+                else:
+                    ret = MinMaxRetType(
+                        values=values.squeeze_(axis=dim_or_other),
+                        indices=indices.squeeze_(axis=dim_or_other),
+                    )
             else:
-                ret = MinMaxRetType(
-                    values=values.squeeze_(axis=dim_or_other),
-                    indices=indices.squeeze_(axis=dim_or_other),
+                vals, inds = _C_ops.min_with_index(
+                    input, dim_or_other, keepdim, False
                 )
+                inds.stop_gradient = True
+                ret = MinMaxRetType(values=vals, indices=inds)
         else:
-            vals, inds = _C_ops.min_with_index(
-                input, dim_or_other, keepdim, False
+            ret = MinMaxRetType(
+                values=input,
+                indices=paddle.zeros(
+                    [], dtype=paddle.int64, device=input.place
+                ),
             )
-            inds.stop_gradient = True
-            ret = MinMaxRetType(values=vals, indices=inds)
     else:
         _check_out_status(out, False)
         ret = _C_ops.minimum(input, dim_or_other)
@@ -780,23 +792,33 @@ def max(
         ret = paddle.max(input)
     elif isinstance(dim_or_other, int):
         _check_out_status(out, True)
-        if in_dynamic_mode() and not input.place.is_gpu_place():
-            _min_max_allow_cpu_composite(input)
-            indices = paddle.argmax(input, axis=dim_or_other, keepdim=True)
-            values = paddle.take_along_axis(input, indices, axis=dim_or_other)
-            if keepdim:
-                ret = MinMaxRetType(values=values, indices=indices)
+        if input.ndim:
+            if in_dynamic_mode() and not input.place.is_gpu_place():
+                _min_max_allow_cpu_composite(input)
+                indices = paddle.argmax(input, axis=dim_or_other, keepdim=True)
+                values = paddle.take_along_axis(
+                    input, indices, axis=dim_or_other
+                )
+                if keepdim:
+                    ret = MinMaxRetType(values=values, indices=indices)
+                else:
+                    ret = MinMaxRetType(
+                        values=values.squeeze_(axis=dim_or_other),
+                        indices=indices.squeeze_(axis=dim_or_other),
+                    )
             else:
-                ret = MinMaxRetType(
-                    values=values.squeeze_(axis=dim_or_other),
-                    indices=indices.squeeze_(axis=dim_or_other),
+                vals, inds = _C_ops.max_with_index(
+                    input, dim_or_other, keepdim, False
                 )
+                inds.stop_gradient = True
+                ret = MinMaxRetType(values=vals, indices=inds)
         else:
-            vals, inds = _C_ops.max_with_index(
-                input, dim_or_other, keepdim, False
+            ret = MinMaxRetType(
+                values=input,
+                indices=paddle.zeros(
+                    [], dtype=paddle.int64, device=input.place
+                ),
             )
-            inds.stop_gradient = True
-            ret = MinMaxRetType(values=vals, indices=inds)
     else:
         _check_out_status(out, False)
         ret = _C_ops.maximum(input, dim_or_other)

python/paddle/tensor/manipulation.py

@@ -64,6 +64,8 @@
         TensorOrTensors,
     )
 
+from paddle.utils.decorator_utils import ForbidKeywordsDecorator
+
 __all__ = []
 
 
@@ -2736,6 +2738,11 @@ def row_stack(x: Sequence[Tensor], name: str | None = None) -> Tensor:
     return paddle.vstack(x, name=name)
 
 
+@ForbidKeywordsDecorator(
+    illegal_keys={"tensor", "split_size_or_sections", "dim"},
+    func_name="paddle.split",
+    correct_name="paddle.compat.split",
+)
 def split(
     x: Tensor,
     num_or_sections: int | Sequence[int],

python/paddle/utils/decorator_utils.py

@@ -123,21 +123,6 @@ def __init__(
         self.default_params = default_params
         warnings.simplefilter("always", category=Warning)
 
-
-# *size => shape decorator
-class SizeArgsDecorator(DecoratorBase):
-    """
-    Usage Example:
-
-    paddle.ones(1, dtype=paddle.float32)
-    paddle.ones(1, 2, 3, dtype=paddle.float32)
-    paddle.ones([1, 2, 3], dtype=paddle.float32)
-    paddle.ones(size=[1, 2, 3], dtype=paddle.float32)
-
-    paddle.ones([1, 2, 3], paddle.float32)
-    paddle.ones(shape=[1, 2, 3], dtype=paddle.float32)
-    """
-
     def process(
         self, args: tuple[Any, ...], kwargs: dict[str, Any]
     ) -> tuple[tuple[Any, ...], dict[str, Any]]:
@@ -235,6 +220,32 @@ def wrapper(*args: _InputT.args, **kwargs: _InputT.kwargs) -> _RetT:
     return decorator
 
 
+# *size => shape decorator
+class SizeArgsDecorator(DecoratorBase):
+    """
+    Usage Example:
+
+    paddle.ones(1, dtype=paddle.float32)
+    paddle.ones(1, 2, 3, dtype=paddle.float32)
+    paddle.ones([1, 2, 3], dtype=paddle.float32)
+    paddle.ones(size=[1, 2, 3], dtype=paddle.float32)
+
+    paddle.ones([1, 2, 3], paddle.float32)
+    paddle.ones(shape=[1, 2, 3], dtype=paddle.float32)
+    """
+
+    def process(
+        self, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> tuple[tuple[Any, ...], dict[str, Any]]:
+        if 'size' in kwargs:
+            kwargs['shape'] = kwargs.pop('size')
+        elif len(args) >= 1 and isinstance(args[0], int):
+            kwargs['shape'] = list(args)
+            args = ()
+
+        return args, kwargs
+
+
 class VariableArgsDecorator(DecoratorBase):
     def __init__(self, var: str) -> None:
         super().__init__()

test/ir/pir/cinn/symbolic/test_infer_sym_shape_unary_op.py

@@ -73,6 +73,45 @@ def test_eval_symbolic(self):
         return True
 
 
+class MaxMinWithIndexNet(paddle.nn.Layer):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        min_vals, min_inds = paddle.compat.min(x, dim=-1, keepdim=False)
+        max_vals, max_inds = paddle.compat.max(x, dim=-1, keepdim=True)
+        return min_vals + max_vals.squeeze(axis=-1), min_inds + max_inds
+
+
+class MinMaxWithIndexOpInferSymbolicShapeTest(TestBase):
+    def prepare_data(self):
+        self.cases = [np.random.rand(3, 4, 5, 6), np.random.rand(257)]
+        self.expected = [
+            [
+                'shape[S0, S1, S2], data[NULL]',
+                'shape[S0, Broadcast(S0, S1), Broadcast(S1, S2), S2], data[NULL]',
+            ],
+            ['shape[], data[NULL]', 'shape[1], data[NULL]'],
+        ]
+
+    def test_eval_symbolic(self):
+        net = MaxMinWithIndexNet()
+
+        for i in range(len(self.cases)):
+            x = self.cases[i]
+            x_spec = InputSpec(
+                shape=[None for index in range(len(x.shape))], dtype='float32'
+            )
+            input_spec = [x_spec]
+            net = apply_to_static(net, False, input_spec)
+            net.eval()
+            check_infer_results(
+                net, input_spec, 'builtin.shadow_output', self.expected[i]
+            )
+
+        return True
+
+
 class AsComplexAsRealNet(paddle.nn.Layer):
     def __init__(self):
         super().__init__()