[API-Compat] Try adding even more unittests.

Author: Enigmatisms

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/unary_infer_sym.cc

@@ -352,7 +352,7 @@ bool MinMaxOpInferSymbolicShape(pir::Operation *op,
     std::vector<symbol::DimExpr> out_sym_shape;
     if (flatten) {
       if (keepdims) {
-        out_sym_shape.emplace_back(std::int64_t(rank));
+        out_sym_shape.resize(rank, std::int64_t(1));
       } else {
         out_sym_shape = {};
       }

paddle/phi/infermeta/unary.cc

@@ -366,90 +366,6 @@ void ArgMinMaxInferMeta(const MetaTensor& x,
   }
 }
 
-void MinMaxWithIndexInferMeta(const MetaTensor& x,
-                              const Scalar& axis,
-                              bool keepdims,
-                              bool flatten,
-                              MetaTensor* val_out,
-                              MetaTensor* ind_out,
-                              MetaConfig config) {
-  DataType val_dtype = x.dtype();
-
-  if (!config.is_runtime && axis.FromTensor()) {
-    std::vector<int64_t> vec;
-    if (flatten) {
-      if (keepdims) {  // NOLINT
-        vec = std::vector<int64_t>(x.dims().size(), -1);
-      } else {
-        vec = {};
-      }
-    } else {
-      if (keepdims) {
-        vec = std::vector<int64_t>(x.dims().size(), -1);
-      } else {
-        vec = std::vector<int64_t>(x.dims().size() - 1, -1);
-      }
-    }
-    val_out->set_dims(common::make_ddim(vec));
-    val_out->set_dtype(val_dtype);
-    ind_out->set_dims(common::make_ddim(vec));
-    ind_out->set_dtype(DataType::INT64);
-    return;
-  }
-  auto int_axis = axis.to<int64_t>();
-  const auto& x_dims = x.dims();
-
-  auto x_rank = x.dims().size();
-  if (x_rank > 0) {
-    PADDLE_ENFORCE_GE(int_axis,
-                      -x_rank,
-                      common::errors::InvalidArgument(
-                          "'axis'(%d) must be greater than or equal to"
-                          " -Rank(X)(%d).",
-                          int_axis,
-                          -x_rank));
-    PADDLE_ENFORCE_LT(
-        int_axis,
-        x_rank,
-        common::errors::InvalidArgument(
-            "'axis'(%d) must be less than Rank(X)(%d) of Input(X).",
-            int_axis,
-            x_rank));
-  } else {
-    // 0-dim tensor
-    PADDLE_ENFORCE_EQ(int_axis == 0 || int_axis == -1,
-                      true,
-                      common::errors::InvalidArgument(
-                          "'axis'(%d) must be 0 or -1 if input tensor is "
-                          "0-dim.",
-                          int_axis));
-  }
-
-  if (int_axis < 0) int_axis += x_rank;
-
-  std::vector<int64_t> vec;
-  if (flatten) {
-    if (keepdims) {  // NOLINT
-      vec = std::vector<int64_t>(x.dims().size(), 1);
-    } else {
-      vec = {};
-    }
-  } else {
-    for (int64_t i = 0; i < int_axis; i++)
-      vec.emplace_back(x_dims[static_cast<int>(i)]);
-    if (keepdims) {
-      vec.emplace_back(static_cast<int64_t>(1));
-    }
-    for (int64_t i = int_axis + 1; i < x_rank; i++)
-      vec.emplace_back(x_dims[static_cast<int>(i)]);
-  }
-
-  val_out->set_dims(common::make_ddim(vec));
-  val_out->set_dtype(val_dtype);
-  ind_out->set_dims(common::make_ddim(vec));
-  ind_out->set_dtype(DataType::INT64);
-}
-
 void ArgsortInferMeta(const MetaTensor& input,
                       int axis,
                       bool descending,
@@ -3034,6 +2950,70 @@ void ModeInferMeta(const MetaTensor& x,
   indices->set_dtype(DataType::INT64);
 }
 
+void MinMaxWithIndexInferMeta(const MetaTensor& x,
+                              const Scalar& axis,
+                              bool keepdims,
+                              bool flatten,
+                              MetaTensor* val_out,
+                              MetaTensor* ind_out,
+                              MetaConfig config) {
+  DataType val_dtype = x.dtype();
+
+  // axis.FromTensor will never be true for this op
+  auto int_axis = axis.to<int64_t>();
+  const auto& x_dims = x.dims();
+
+  auto x_rank = x.dims().size();
+  if (x_rank > 0) {
+    PADDLE_ENFORCE_GE(int_axis,
+                      -x_rank,
+                      common::errors::InvalidArgument(
+                          "'axis'(%d) must be greater than or equal to"
+                          " -Rank(X)(%d).",
+                          int_axis,
+                          -x_rank));
+    PADDLE_ENFORCE_LT(
+        int_axis,
+        x_rank,
+        common::errors::InvalidArgument(
+            "'axis'(%d) must be less than Rank(X)(%d) of Input(X).",
+            int_axis,
+            x_rank));
+  } else {
+    // 0-dim tensor
+    PADDLE_ENFORCE_EQ(int_axis == 0 || int_axis == -1,
+                      true,
+                      common::errors::InvalidArgument(
+                          "'axis'(%d) must be 0 or -1 if input tensor is "
+                          "0-dim.",
+                          int_axis));
+  }
+
+  if (int_axis < 0) int_axis += x_rank;
+
+  std::vector<int64_t> vec;
+  if (flatten) {
+    if (keepdims) {  // NOLINT
+      vec = std::vector<int64_t>(x.dims().size(), 1);
+    } else {
+      vec = {};
+    }
+  } else {
+    for (int64_t i = 0; i < int_axis; i++)
+      vec.emplace_back(x_dims[static_cast<int>(i)]);
+    if (keepdims) {
+      vec.emplace_back(static_cast<int64_t>(1));
+    }
+    for (int64_t i = int_axis + 1; i < x_rank; i++)
+      vec.emplace_back(x_dims[static_cast<int>(i)]);
+  }
+
+  val_out->set_dims(common::make_ddim(vec));
+  val_out->set_dtype(val_dtype);
+  ind_out->set_dims(common::make_ddim(vec));
+  ind_out->set_dtype(DataType::INT64);
+}
+
 void MultinomialInferMeta(const MetaTensor& x,
                           const Scalar& num_samples,
                           bool replacement,

paddle/phi/ops/yaml/ops.yaml

@@ -3586,7 +3586,7 @@
     func : max_with_index
     data_type : x
   backward : max_with_index_grad
-  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : maxout
   args : (Tensor x, int groups, int axis = 1)
@@ -3706,7 +3706,7 @@
     func : min_with_index
     data_type : x
   backward : min_with_index_grad
-  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : mish
   args : (Tensor x, float lambda)

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

@@ -73,45 +73,6 @@ 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/ir/pir/cinn/symbolic/test_minmax_infer_sym.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2025 PaddlePaddle 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.
+
+import sys
+import unittest
+from os.path import dirname
+
+import numpy as np
+from test_infer_sym_shape_utils import (
+    TestBase,
+    check_infer_results,
+)
+
+import paddle
+from paddle.static import InputSpec
+
+sys.path.append(dirname(dirname(__file__)))
+from utils import apply_to_static
+
+# NOTE(SigureMo): Disable the CSE optimization to avoid op number change.
+paddle.set_flags({"FLAGS_enable_cse_in_dy2st": False})
+
+
+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 MinMaxWithIndexRawNet(paddle.nn.Layer):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        x = x * 2 + 1
+        min_vals, min_inds = paddle._C_ops.min_with_index(x, 1, False, True)
+        max_vals, max_inds = paddle._C_ops.max_with_index(x, 2, True, True)
+        return min_vals + max_vals.squeeze(), min_inds * max_inds
+
+
+class MinMaxWithIndexOpRawInferShapeTest(TestBase):
+    def prepare_data(self):
+        self.cases = [np.random.rand(4, 5, 6), np.random.rand(3, 7, 1, 2)]
+        self.expected = [
+            [
+                'shape[], data[NULL]',
+                'shape[1, 1, 1], data[NULL]',
+            ],
+            ['shape[], data[NULL]', 'shape[1, 1, 1, 1], data[NULL]'],
+        ]
+
+    @unittest.skipIf(
+        not paddle.core.is_compiled_with_cuda(),
+        "core is not compiled with CUDA, skipping",
+    )
+    def test_eval_symbolic(self):
+        net = MinMaxWithIndexRawNet()
+
+        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
+
+
+if __name__ == "__main__":
+    unittest.main()