[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/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__()

test/legacy_test/test_minmax_with_index_op.py

@@ -232,6 +232,11 @@ def test_check_grad(self):
 
 
 class TestMinMaxWithIndexPlace(unittest.TestCase):
+    """min/max_with_index has no CPU version, so when CUDA is not available,
+    we skip all the above test. A runtime error will be emitted if min/max_with_index
+    is called on CPU, this unit test tries capturing it.
+    """
+
     def init(self):
         self.input_shape = [30, 10, 10]
         self.data = np.random.randn(30, 10, 10)

test/legacy_test/test_zero_dim_sundry_dygraph_api.py

@@ -551,6 +551,61 @@ def test_argmax(self):
         out = paddle.argmax(x, keepdim=True)
         self.assertEqual(out.shape, [1, 1])
 
+    def _make_compat_minmax_test(self, func_name):
+        # 1) x is 0D
+        x = paddle.rand([])
+        val1, ind1 = func_name(x, 0)
+        val2, ind2 = func_name(x, -1)
+        val3 = func_name(x)
+
+        self.assertEqual(val1.shape, [])
+        self.assertEqual(ind1.shape, [])
+        np.testing.assert_allclose(val1, x)
+        np.testing.assert_allclose(ind1, 0)
+
+        self.assertEqual(val2.shape, [])
+        self.assertEqual(ind2.shape, [])
+        np.testing.assert_allclose(val2, x)
+        np.testing.assert_allclose(ind2, 0)
+
+        self.assertEqual(val3.shape, [])
+        np.testing.assert_allclose(val3, x)
+
+        # 2) x is 1D
+        x = paddle.rand([5])
+        val, ind = func_name(x, 0)
+        self.assertEqual(val.shape, [])
+        self.assertEqual(ind.shape, [])
+
+        # 3) x is ND
+        x = paddle.rand([3, 5])
+        val, ind = func_name(x, dim=1)
+        self.assertEqual(val.shape, [3])
+        self.assertEqual(ind.shape, [3])
+
+        val = func_name(x)
+        self.assertEqual(val.shape, [])
+
+        # 4) x is ND, keepdim=True
+        x = paddle.rand([3, 5])
+        val, ind = func_name(x, dim=0, keepdim=True)
+        self.assertEqual(val.shape, [1, 5])
+        self.assertEqual(ind.shape, [1, 5])
+
+        # 5) test backward
+        x = paddle.randn([4, 5])
+        x.stop_gradient = False
+
+        val, ind = func_name(x, dim=0)
+        val.backward()
+        self.assertEqual(x.grad.shape, [4, 5])
+
+    def test_compat_min(self):
+        self._make_compat_minmax_test(paddle.compat.min)
+
+    def test_compat_max(self):
+        self._make_compat_minmax_test(paddle.compat.max)
+
     def test_kthvalue(self):
         # 1) x is 0D
         x = paddle.randn([])