[API Compatibility No.155] Keep input/target alias for bce_with_logits-part

Author: Aidenwu0209

paconvert/api_mapping.json

@@ -8848,7 +8848,7 @@
     "min_input_args": 2
   },
   "torch.nn.functional.binary_cross_entropy_with_logits": {
-    "Matcher": "SizeAverageMatcher",
+    "Matcher": "BCEWithLogitsAliasMatcher",
     "paddle_api": "paddle.nn.functional.binary_cross_entropy_with_logits",
     "args_list": [
       "input",
@@ -8859,10 +8859,6 @@
       "reduction",
       "pos_weight"
     ],
-    "kwargs_change": {
-      "input": "logit",
-      "target": "label"
-    },
     "min_input_args": 2
   },
   "torch.nn.functional.celu": {

paconvert/api_matcher.py

@@ -4218,6 +4218,107 @@ def generate_code(self, kwargs):
         return GenericMatcher.generate_code(self, kwargs)
 
 
+class BCEWithLogitsAliasMatcher(BaseMatcher):
+    def _generate_code_with_args(self, args, kwargs):
+        kwargs_change_value = self.api_mapping_dict.get("kwargs_change", {}).values()
+        kwargs = self.change_kwargs(
+            kwargs,
+            [
+                "layout",
+                "device",
+                "memory_format",
+                "inplace",
+                "generator",
+                "non_blocking",
+                "async",
+            ],
+        )
+        kwargs = self.set_paddle_default_kwargs(kwargs)
+
+        dtype_v = "None"
+        if "dtype" in kwargs and "dtype" not in kwargs_change_value:
+            dtype_v = kwargs.pop("dtype")
+
+        pin_memory_v = "(False)"
+        if "pin_memory" in kwargs and "pin_memory" not in kwargs_change_value:
+            pin_memory_v = kwargs.pop("pin_memory")
+
+        stop_gradient_v = "None"
+        if "requires_grad" in kwargs and "requires_grad" not in kwargs_change_value:
+            stop_gradient_v = "not " + kwargs.pop("requires_grad").strip("()")
+
+        out_v = "None"
+        if "out" in kwargs and "out" not in kwargs_change_value:
+            out_v = kwargs.pop("out")
+
+        code = "{}({})".format(
+            self.get_paddle_api(), self.args_and_kwargs_to_str(args, kwargs)
+        )
+
+        if dtype_v != "None":
+            code += ".astype({})".format(dtype_v)
+
+        if pin_memory_v != "(False)":
+            code += ".pin_memory()"
+
+        if stop_gradient_v != "None" and out_v != "None":
+            API_TEMPLATE = textwrap.dedent(
+                """
+                paddle.assign({}, output={})
+                {}.stop_gradient = {}
+                {}
+                """
+            )
+            code = API_TEMPLATE.format(code, out_v, out_v, stop_gradient_v, out_v)
+        elif stop_gradient_v != "None" and out_v == "None":
+            API_TEMPLATE = textwrap.dedent(
+                """
+                {} = {}
+                {}.stop_gradient = {}
+                {}
+                """
+            )
+            out = get_unique_name("out")
+            code = API_TEMPLATE.format(out, code, out, stop_gradient_v, out)
+        elif out_v != "None" and stop_gradient_v == "None":
+            API_TEMPLATE = textwrap.dedent(
+                """
+                paddle.assign({}, output={})
+                """
+            )
+            code = API_TEMPLATE.format(code, out_v)
+
+        return code
+
+    def get_paddle_nodes(self, args, kwargs):
+        new_kwargs = self.parse_args_and_kwargs(args, kwargs)
+        if new_kwargs == "misidentify":
+            return "misidentify"
+        elif new_kwargs is None:
+            return None
+
+        process_reduce_and_size_average(new_kwargs)
+
+        new_args = self.parse_args(args)
+        call_args = new_args[:2]
+        if len(new_args) >= 3 and "weight" in new_kwargs:
+            call_args.append(new_kwargs.pop("weight"))
+
+        if len(call_args) >= 1:
+            new_kwargs.pop("input", None)
+        if len(call_args) >= 2:
+            new_kwargs.pop("target", None)
+
+        new_code = self._generate_code_with_args(call_args, new_kwargs)
+        if new_code == "misidentify":
+            return "misidentify"
+        elif new_code == "unchange":
+            return "unchange"
+        elif new_code:
+            return ast.parse(new_code).body
+        return None
+
+
 class CudaNvtxRangePushMatcher(BaseMatcher):
     def generate_code(self, kwargs):
         code = "{}({})".format(self.get_paddle_api(), kwargs["msg"])

tests/test_nn_functional_binary_cross_entropy_with_logits.py

@@ -25,8 +25,10 @@ def test_case_1():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target)
         """
     )
@@ -37,8 +39,10 @@ def test_case_2():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, weight=None)
         """
     )
@@ -49,8 +53,10 @@ def test_case_3():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, reduce=True)
         """
     )
@@ -61,8 +67,10 @@ def test_case_4():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, reduce=False)
         """
     )
@@ -73,8 +81,10 @@ def test_case_5():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, reduction='none')
         """
     )
@@ -85,8 +95,10 @@ def test_case_6():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, reduction='mean')
         """
     )
@@ -97,8 +109,10 @@ def test_case_7():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, reduction='sum')
         """
     )
@@ -109,8 +123,10 @@ def test_case_8():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, weight=None, size_average=None, reduce=True, reduction='sum', pos_weight=None)
         """
     )
@@ -122,8 +138,10 @@ def test_case_9():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(a, target, None, None, True, 'sum', None)
         """
     )
@@ -135,22 +153,103 @@ def test_case_10():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
-        result = torch.nn.functional.binary_cross_entropy_with_logits(input=a, target=target, weight=None, size_average=None, reduce=True, reduction='sum', pos_weight=None)
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
+        result = torch.nn.functional.binary_cross_entropy_with_logits(input=a, target=target)
         """
     )
-    obj.run(pytorch_code, ["result"])
+    expect_paddle_code = textwrap.dedent(
+        """
+        import paddle
+
+        a = paddle.zeros(3)
+        a.stop_gradient = not True
+        target = paddle.zeros(3)
+        target[1] = 1.0
+        result = paddle.nn.functional.binary_cross_entropy_with_logits(input=a, target=target)
+        """
+    )
+    obj.run(pytorch_code, expect_paddle_code=expect_paddle_code)
 
 
-# generated by validate_unittest autofix, based on test_case_8
 def test_case_11():
     pytorch_code = textwrap.dedent(
         """
         import torch
-        a = torch.zeros(3, requires_grad=True)
-        target = torch.tensor([0.,1.,0.])
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
+        result = torch.nn.functional.binary_cross_entropy_with_logits(target=target, input=a, reduction='sum', weight=None, pos_weight=None)
+        """
+    )
+    expect_paddle_code = textwrap.dedent(
+        """
+        import paddle
+
+        a = paddle.zeros(3)
+        a.stop_gradient = not True
+        target = paddle.zeros(3)
+        target[1] = 1.0
+        result = paddle.nn.functional.binary_cross_entropy_with_logits(
+            target=target, input=a, reduction="sum", weight=None, pos_weight=None
+        )
+        """
+    )
+    obj.run(pytorch_code, expect_paddle_code=expect_paddle_code)
+
+
+def test_case_12():
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
+        result = torch.nn.functional.binary_cross_entropy_with_logits(input=a, target=target, weight=None, size_average=None, reduce=True, reduction='sum', pos_weight=None)
+        """
+    )
+    expect_paddle_code = textwrap.dedent(
+        """
+        import paddle
+
+        a = paddle.zeros(3)
+        a.stop_gradient = not True
+        target = paddle.zeros(3)
+        target[1] = 1.0
+        result = paddle.nn.functional.binary_cross_entropy_with_logits(
+            input=a, target=target, weight=None, reduction="mean", pos_weight=None
+        )
+        """
+    )
+    obj.run(pytorch_code, expect_paddle_code=expect_paddle_code)
+
+
+def test_case_13():
+    pytorch_code = textwrap.dedent(
+        """
+        import torch
+        a = torch.zeros(3)
+        a.requires_grad = True
+        target = torch.zeros(3)
+        target[1] = 1.0
         result = torch.nn.functional.binary_cross_entropy_with_logits(pos_weight=None, reduction='sum', reduce=True, size_average=None, weight=None, target=target, input=a)
         """
     )
-    obj.run(pytorch_code, ["result"])
+    expect_paddle_code = textwrap.dedent(
+        """
+        import paddle
+
+        a = paddle.zeros(3)
+        a.stop_gradient = not True
+        target = paddle.zeros(3)
+        target[1] = 1.0
+        result = paddle.nn.functional.binary_cross_entropy_with_logits(
+            pos_weight=None, reduction="mean", weight=None, target=target, input=a
+        )
+        """
+    )
+    obj.run(pytorch_code, expect_paddle_code=expect_paddle_code)