fix CI

Author: zhwesky2010

paconvert/api_mapping.json

@@ -5328,9 +5328,6 @@
       "axis": 0
     }
   },
-  "torch.float8_e4m3fn": {
-    "Matcher": "ChangePrefixMatcher"
-  },
   "torch.float_power": {
     "Matcher": "FloatPowerMatcher",
     "min_input_args": 2,

paconvert/attribute_mapping.json

@@ -68,7 +68,7 @@
   },
   "torch.autograd.function.FunctionCtx.saved_tensors": {
     "Matcher": "Attribute2Func",
-    "paddle_api": "paddle.autograd.PyLayerContext.saved_tensor"
+    "paddle_api": "paddle.autograd.function.FunctionCtx.saved_tensor"
   },
   "torch.autograd.profiler.profile.self_cpu_time_total": {},
   "torch.backends.cuda.matmul.allow_tf32": {
@@ -148,6 +148,9 @@
   "torch.float64": {
     "Matcher": "ChangePrefixMatcher"
   },
+  "torch.float8_e4m3fn": {
+    "Matcher": "ChangePrefixMatcher"
+  },
   "torch.inf": {
     "Matcher": "ChangePrefixMatcher"
   },

paconvert/base.py

@@ -383,7 +383,7 @@ def parse_func(self, func):
         self.paddleClass = new_func[0 : new_func.rfind(".")]
         if self.get_paddle_api():
             new_paddle_api = re.sub(
-                "paddle.Tensor|paddle.nn.Module|paddle.optimizer.Optimizer|paddle.distribution.Distribution|paddle.autograd.function.FunctionCtx|paddle.autograd.PyLayerContext|paddle.profiler.Profiler",
+                "paddle.Tensor|paddle.nn.Module|paddle.optimizer.Optimizer|paddle.distribution.Distribution|paddle.autograd.function.FunctionCtx|paddle.profiler.Profiler",
                 re.escape(self.paddleClass),
                 self.get_paddle_api(),
             )

paconvert/transformer/basic_transformer.py

@@ -119,11 +119,14 @@ def visit_Attribute(self, node):
                 node.lineno,
             )
 
-            matcher = self.get_api_matcher(torch_api)
-            # can be api_matcher or attribute_matcher
-            if matcher is None:
-                matcher = self.get_attribute_mather(torch_api)
-
+            # can be attribute_matcher or attribute_matcher
+            attribute_matcher = self.get_attribute_matcher(torch_api)
+            api_matcher = self.get_api_matcher(torch_api)
+            assert (
+                attribute_matcher and api_matcher
+            ), f"{torch_api} can not be both in attribute_matcher and api_matcher"
+
+            matcher = attribute_matcher or api_matcher
             if matcher:
                 paddle_api = matcher.get_paddle_api()
                 if paddle_api == "delete":
@@ -275,7 +278,7 @@ def visit_Attribute(self, node):
         return node
 
     def trans_class_attribute(self, node, torch_api):
-        matcher = self.get_attribute_mather(torch_api)
+        matcher = self.get_attribute_matcher(torch_api)
         if matcher:
             self.all_api_map[torch_api]["paddle_api"] = (
                 matcher.get_paddle_api() if matcher.get_paddle_api() else ""
@@ -736,6 +739,9 @@ def in_api_mapping(self, torch_api):
     def get_api_matcher(self, torch_api):
         api_mapping_dict = {}
         if torch_api in GlobalManager.ALIAS_MAPPING:
+            assert (
+                torch_api not in GlobalManager.API_MAPPING
+            ), f"{torch_api} can not be both in alias mapping and api mapping"
             torch_api = GlobalManager.ALIAS_MAPPING[torch_api]
         if torch_api in GlobalManager.API_MAPPING:
             api_mapping_dict = GlobalManager.API_MAPPING[torch_api]
@@ -759,10 +765,12 @@ def in_attribute_mapping(self, torch_api):
             return True
         return False
 
-    def get_attribute_mather(self, torch_api):
+    def get_attribute_matcher(self, torch_api):
         attr_mapping_dict = {}
-
         if torch_api in GlobalManager.ALIAS_MAPPING:
+            assert (
+                torch_api not in GlobalManager.ATTRIBUTE_MAPPING
+            ), f"{torch_api} can not be both in alias mapping and attribute mapping"
             torch_api = GlobalManager.ALIAS_MAPPING[torch_api]
         if torch_api in GlobalManager.ATTRIBUTE_MAPPING:
             attr_mapping_dict = GlobalManager.ATTRIBUTE_MAPPING[torch_api]

tests/test_Tensor_nanquantile.py

@@ -56,144 +56,204 @@ def test_case_3():
 
 
 def test_case_4():
-    """With dim keyword argument (using alias)"""
+    """With keepdim keyword argument"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(0.5, dim=1)
+        result = x.nanquantile(0.25, 0, keepdim=True)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_5():
-    """With keepdim keyword argument"""
+    """Multiple quantile values"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(0.25, 0, keepdim=True)
+        result = x.nanquantile(torch.tensor([0.25, 0.5, 0.75]))
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_6():
-    """Multiple quantile values"""
+    """3D tensor input"""
     pytorch_code = textwrap.dedent(
         """
         import torch
-        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(torch.tensor([0.25, 0.5, 0.75]))
+        x = torch.tensor([[[1.0, float('nan')], [3.0, 4.0]], [[5.0, 6.0], [float('nan'), 8.0]]])
+        result = x.nanquantile(0.5, 2)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_7():
-    """Keywords in different order (dim first)"""
+    """Mixed parameter styles with dim and keepdim"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(q=0.5, dim=1, keepdim=False)
+        result = x.nanquantile(0.5, dim=1, keepdim=True)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_8():
-    """Keywords completely out of order"""
+    """Verify NaN handling - all NaN row"""
     pytorch_code = textwrap.dedent(
         """
         import torch
-        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(dim=1, q=0.5, keepdim=True)
+        x = torch.tensor([[float('nan'), float('nan'), float('nan')], [1.0, 2.0, 3.0]])
+        result = x.nanquantile(0.5, 1)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_9():
-    """1D tensor input"""
+    """Quantile at lower boundary"""
     pytorch_code = textwrap.dedent(
         """
         import torch
-        x = torch.tensor([1.0, 2.0, float('nan'), 4.0, 5.0])
-        result = x.nanquantile(0.5)
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(0.0, 1)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_10():
-    """3D tensor input"""
+    """Quantile at upper boundary"""
     pytorch_code = textwrap.dedent(
         """
         import torch
-        x = torch.tensor([[[1.0, float('nan')], [3.0, 4.0]], [[5.0, 6.0], [float('nan'), 8.0]]])
-        result = x.nanquantile(0.5, 2)
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(1.0, 1)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_11():
-    """Mixed parameter styles"""
+    """Chained method calls"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(0.5, dim=1, keepdim=True)
+        result = x.nanquantile(0.5, 1).nanquantile(0.5)
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_12():
-    """Verify NaN handling - all NaN row"""
+    """With interpolation='lower'"""
     pytorch_code = textwrap.dedent(
         """
         import torch
-        x = torch.tensor([[float('nan'), float('nan'), float('nan')], [1.0, 2.0, 3.0]])
-        result = x.nanquantile(0.5, 1)
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(0.5, dim=1, interpolation='lower')
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_13():
-    """Quantile at boundaries"""
+    """With interpolation='higher'"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(0.0, 1)
+        result = x.nanquantile(0.5, dim=1, interpolation='higher')
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_14():
-    """Quantile at upper boundary"""
+    """With interpolation='midpoint'"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(1.0, 1)
+        result = x.nanquantile(0.5, dim=1, interpolation='midpoint')
     """
     )
     obj.run(pytorch_code, ["result"])
 
 
 def test_case_15():
-    """Chained method calls"""
+    """With interpolation='nearest'"""
     pytorch_code = textwrap.dedent(
         """
         import torch
         x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
-        result = x.nanquantile(0.5, 1).nanquantile(0.5)
+        result = x.nanquantile(0.5, dim=1, interpolation='nearest')
+    """
+    )
+    obj.run(pytorch_code, ["result"])
+
+
+def test_case_16():
+    """Multiple quantiles with interpolation parameter"""
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(torch.tensor([0.25, 0.5, 0.75]), dim=1, interpolation='midpoint')
+    """
+    )
+    obj.run(pytorch_code, ["result"])
+
+
+def test_case_17():
+    """With dim=None explicitly (flatten behavior)"""
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(0.5, dim=None)
+    """
+    )
+    obj.run(pytorch_code, ["result"])
+
+
+def test_case_18():
+    """With dim=None and keepdim=True"""
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(0.5, dim=None, keepdim=True)
+    """
+    )
+    obj.run(pytorch_code, ["result"])
+
+
+def test_case_19():
+    """Multiple quantiles with interpolation on 3D tensor"""
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[[1.0, float('nan')], [3.0, 4.0]], [[5.0, 6.0], [float('nan'), 8.0]]])
+        result = x.nanquantile(torch.tensor([0.25, 0.75]), dim=0, interpolation='lower')
+    """
+    )
+    obj.run(pytorch_code, ["result"])
+
+
+def test_case_20():
+    """All parameters including keywords in mixed order"""
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0, float('nan')], [4.0, 5.0, 6.0]])
+        result = x.nanquantile(q=0.5, interpolation='higher', dim=1, keepdim=False)
     """
     )
     obj.run(pytorch_code, ["result"])

tests/test_cummax.py

@@ -106,3 +106,17 @@ def test_case_6():
         """
     )
     obj.run(pytorch_code, ["result", "values", "indices"])
+
+
+def test_case_7():
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+        values = torch.empty(2, 2)
+        indices = torch.empty(2, 2, dtype=torch.int64)
+        out = (values, indices)
+        result = torch.cummax(out=out, dim=0, input=x)
+        """
+    )
+    obj.run(pytorch_code, ["result", "out"])

tests/test_cummin.py

@@ -106,3 +106,17 @@ def test_case_6():
         """
     )
     obj.run(pytorch_code, ["result", "values", "indices"])
+
+
+def test_case_7():
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+        values = torch.empty(2, 2)
+        indices = torch.empty(2, 2, dtype=torch.int64)
+        out = (values, indices)
+        result = torch.cummin(out=out, dim=0, input=x)
+        """
+    )
+    obj.run(pytorch_code, ["result", "out"])

tests/test_inner.py

@@ -69,7 +69,6 @@ def test_case_4():
     obj.run(pytorch_code, ["result"])
 
 
-# The paddle input does not support integer type
 def test_case_5():
     pytorch_code = textwrap.dedent(
         """

tests/test_rot90.py

@@ -114,3 +114,13 @@ def test_case_8():
         """
     )
     obj.run(pytorch_code, ["y", "x_grad"], check_stop_gradient=False)
+
+
+def test_case_9():
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        result = torch.rot90(dims=[0, 1], k=1, input=torch.tensor([[1, 2, 3], [4, 5, 6]]))
+        """
+    )
+    obj.run(pytorch_code, ["result"])