support argmax without dim kwargs (pytorch#14710)

Summary:

As title, in PyTorch, when dim is not set, it will flatten the input and get argmax as dim=0. Add a pass to reshape the input when dim is not set and consolidate test case

Differential Revision: D83606497

Author: cccclai

backends/qualcomm/_passes/__init__.py

@@ -31,6 +31,7 @@
 from .fuse_consecutive_transpose import FuseConsecutiveTranspose
 from .i64_to_i32 import I64toI32
 from .insert_io_qdq import InsertIOQDQ
+from .insert_reshape_for_argmax import InsertReshapeForArgmax
 from .insert_requantize import InsertRequantize
 from .layout_transform import LayoutTransform
 from .lift_constant_scalar_operands import LiftConstantScalarOperands
@@ -44,7 +45,6 @@
 from .seq_mse import SeqMSE
 from .tag_quant_io import TagQuantIO
 
-
 __all__ = [
     AnnotateAdaptiveAvgPool1D,
     AnnotateQuantAttrs,
@@ -73,6 +73,7 @@
     FuseConsecutiveTranspose,
     I64toI32,
     InsertIOQDQ,
+    InsertReshapeForArgmax,
     InsertRequantize,
     LayoutTransform,
     LiftConstantScalarOperands,

backends/qualcomm/_passes/insert_reshape_for_argmax.py

@@ -0,0 +1,59 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from executorch.exir.pass_base import ExportPass, PassResult
+from executorch.exir.passes import dead_code_elimination_pass
+
+class InsertReshapeForArgmax(ExportPass):
+    """
+    Rewrite `aten.argmax.default` with `dim=None` into
+    a reshape-to-1D followed by argmax(dim=0).
+
+    PyTorch semantics:
+      torch.argmax(x, dim=None) -> flatten(x) then argmax along axis=0
+
+    QNN requires an explicit axis, so we insert the reshape.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.op_map = {torch.ops.aten.argmax.default}
+
+    def call(self, graph_module: torch.fx.GraphModule):
+        graph = graph_module.graph
+        modified = False
+
+        for n in list(graph.nodes):
+            if n.target in self.op_map:
+                dim_arg = None if len(n.args) == 1 else n.args[1]
+
+                if dim_arg is None:
+                    inp = n.args[0]
+
+                    # Insert reshape before argmax
+                    with graph.inserting_before(n):
+                        reshape_node = graph.create_node(
+                            "call_function",
+                            torch.ops.aten.reshape.default,
+                            (inp, [-1]),
+                            {},
+                        )
+                        reshape_node.meta = dict(inp.meta)
+                        if "val" in inp.meta:
+                            reshape_node.meta["val"] = inp.meta["val"].reshape(-1)
+
+                    # Rewrite argmax: take reshape_node as input, set dim=0
+                    n.args = (reshape_node, 0, *n.args[2:])
+                
+                modified = True
+
+
+        if modified:
+            graph_module.recompile()
+            dead_code_elimination_pass(graph_module)
+
+        return PassResult(graph_module, modified)

backends/qualcomm/_passes/qnn_pass_manager.py

@@ -37,6 +37,7 @@
     I64toI32,
     InsertIOQDQ,
     InsertRequantize,
+    InsertReshapeForArgmax,
     LayoutTransform,
     LiftConstantScalarOperands,
     RecomposePixelUnshuffle,
@@ -207,6 +208,7 @@ def transform_for_annotation_pipeline(self, graph_module: GraphModule):
         self.add_pass(DecomposeLinalgVectorNorm(quantization_capture=True))
         self.add_pass(ReplaceInfValues())
         self.add_pass(LiftConstantScalarOperands())
+        self.add_pass(InsertReshapeForArgmax())
         return self._transform(graph_module)
 
     def transform_for_export_pipeline(
@@ -226,6 +228,7 @@ def transform_for_export_pipeline(
             self.add_pass(ConvertLinearToConv2d(exported_program))
         self.add_pass(ConvertSquareToPow())
         self.add_pass(LiftConstantScalarOperands())
+        self.add_pass(InsertReshapeForArgmax())
         self._transform(exported_program.graph_module)
         ep = lift_constant_tensor_pass(exported_program)
         return ep

backends/qualcomm/builders/op_argmax.py

@@ -46,7 +46,7 @@ def define_node(
             nodes_to_wrappers,
         )
         argmax_output_tensors = [argmax_out_tensor_wrapper]
-
+        print("[ARGMAX]: node: ", node, " node.args: ", node.args)
         dim = cast(int, node.args[1])
         if dim < 0:
             dim = dim % len(input_tensor.shape)

backends/qualcomm/quantizer/quantizer.py

@@ -387,7 +387,10 @@ def transform_for_annotation(self, model: GraphModule) -> GraphModule:
         Returns:
             GraphModule: The transformed model.
         """
-        return QnnPassManager().transform_for_annotation_pipeline(model)
+        ret = QnnPassManager().transform_for_annotation_pipeline(model)
+        print("after transform_for_annotation")
+        ret.print_readable()
+        return ret
 
     def validate(self, model: GraphModule) -> None:
         pass

backends/qualcomm/tests/TARGETS

@@ -47,3 +47,17 @@ runtime.python_library(
         ":test_qnn_delegate"
     ]
 )
+
+runtime.python_test(
+    name = "test_passes",
+    srcs = [
+        "test_passes.py",
+    ],
+    deps = [
+        "fbsource//third-party/pypi/expecttest:expecttest",  # @manual
+        "//caffe2:torch",
+        "//executorch/exir:lib",
+        "//executorch/backends/qualcomm/_passes:passes",
+        "//executorch/backends/qualcomm/builders:builders",
+    ],
+)

backends/qualcomm/tests/models.py

@@ -5,7 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 import torch
-
+from typing import Optional
 
 # module with related operator only
 
@@ -170,12 +170,13 @@ def forward(self, y):
 
 
 class Argmax(torch.nn.Module):
-    def __init__(self):
+    def __init__(self, dim: Optional[int] = None, keepdim: bool = False):
         super().__init__()
+        self.dim = dim
+        self.keepdim = keepdim
 
     def forward(self, x):
-        x = torch.argmax(x, dim=0, keepdim=True)
-        return x
+        return torch.argmax(x, dim=self.dim, keepdim=self.keepdim)
 
 
 class Argmin(torch.nn.Module):

backends/qualcomm/tests/test_passes.py

@@ -0,0 +1,42 @@
+import unittest
+import torch
+from executorch.backends.qualcomm._passes import InsertReshapeForArgmax
+
+class TestPasses(unittest.TestCase):
+    def test_insert_reshape_for_argmax(self):
+        class ArgmaxModule(torch.nn.Module):
+            def forward(self, x):
+                return torch.argmax(x, dim=None)
+
+        mod = ArgmaxModule()
+
+        x = torch.tensor([[1.0, 5.0], [3.0, 2.0]])
+        ep = torch.export.export(mod, (x, ))
+        # Run original module for reference
+        ref = mod(x)
+
+        reshape_nodes = [n for n in ep.graph.nodes if n.target == torch.ops.aten.reshape.default]
+        argmax_nodes = [n for n in ep.graph.nodes if n.target == torch.ops.aten.argmax.default]
+        self.assertTrue(len(reshape_nodes) == 0, "Reshape node not inserted")
+        self.assertTrue(len(argmax_nodes) == 1, "Argmax node missing")
+
+        InsertReshapeForArgmax()(ep.graph_module)
+
+        out = ep.graph_module(x)
+        
+        # Check graph structure: argmax should take a reshape as input
+        reshape_nodes = [n for n in ep.graph.nodes if n.target == torch.ops.aten.reshape.default]
+        argmax_nodes = [n for n in ep.graph.nodes if n.target == torch.ops.aten.argmax.default]
+        self.assertTrue(len(reshape_nodes) == 1, "Reshape node should be inserted")
+        self.assertTrue(len(argmax_nodes) == 1, "Argmax node missing")
+
+
+        argmax_node = argmax_nodes[0]
+        self.assertEqual(argmax_node.args[1], 0, "Argmax dim not set to 0")
+
+        # Execute new graph and compare with reference
+        out = ep.graph_module(x)
+        self.assertTrue(torch.equal(*out, ref), f"Output mismatch: got {out}, expected {ref}")
+
+if __name__ == "__main__":
+    unittest.main()

backends/qualcomm/tests/test_qnn_delegate.py

@@ -173,9 +173,33 @@ def test_qnn_backend_arange(self):
                 self.lower_module_and_test_output(module, sample_input)
 
     def test_qnn_backend_argmax(self):
-        module = Argmax()  # noqa: F405
-        sample_input = (torch.randn(16, 3, 4, 4),)
-        self.lower_module_and_test_output(module, sample_input)
+        test_cases = [
+            {
+                "module": Argmax(),
+                "sample_input": (torch.randn(16, 3, 4, 4),),
+            },
+            {
+                "module": Argmax(dim=0, keepdim=True),
+                "sample_input": (torch.randn(16, 3, 4, 4),),
+            },
+            {
+                "module": Argmax(dim=1, keepdim=False),
+                "sample_input": (torch.randn(8, 5),),
+            },
+            {
+                "module": Argmax(dim=None, keepdim=False),
+                "sample_input": (torch.tensor([5.0]),),
+            },
+            {
+                "module": Argmax(dim=2, keepdim=True),
+                "sample_input": (torch.randn(2, 3, 4),),
+            },
+        ]
+
+        for i, case in enumerate(test_cases):
+            with self.subTest(i=i):
+                self.lower_module_and_test_output(case["module"], case["sample_input"])
+
 
     def test_qnn_backend_argmin(self):
         module = Argmin()  # noqa: F405
@@ -1709,11 +1733,36 @@ def test_qnn_backend_arange(self):
                 module = self.get_qdq_module(module, sample_input)
                 self.lower_module_and_test_output(module, sample_input)
 
+
     def test_qnn_backend_argmax(self):
-        module = Argmax()  # noqa: F405
-        sample_input = (torch.randn(16, 3, 4, 4),)
-        module = self.get_qdq_module(module, sample_input)
-        self.lower_module_and_test_output(module, sample_input)
+        test_cases = [
+            {
+                "module": Argmax(),
+                "sample_input": (torch.randn(16, 3, 4, 4),),
+            },
+            {
+                "module": Argmax(dim=0, keepdim=True),
+                "sample_input": (torch.randn(16, 3, 4, 4),),
+            },
+            {
+                "module": Argmax(dim=1, keepdim=False),
+                "sample_input": (torch.randn(8, 5),),
+            },
+            {
+                "module": Argmax(dim=None, keepdim=False),
+                "sample_input": (torch.tensor([5.0]),),
+            },
+            {
+                "module": Argmax(dim=2, keepdim=True),
+                "sample_input": (torch.randn(2, 3, 4),),
+            },
+        ]
+
+        for i, case in enumerate(test_cases):
+            with self.subTest(i=i):
+                module = self.get_qdq_module(case["module"], case["sample_input"])
+                self.lower_module_and_test_output(case["module"], case["sample_input"])
+
 
     def test_qnn_backend_argmin(self):
         module = Argmin()  # noqa: F405