[Dy2St] pir dy2st unittest verification - Part 9

python/paddle/base/framework.py

@@ -1754,19 +1754,18 @@ def clear_gradient(self):
                 >>> import numpy as np
 
                 >>> x = np.ones([2, 2], np.float32)
-                >>> with base.dygraph.guard():
-                ...     inputs2 = []
-                ...     for _ in range(10):
-                ...         tmp = base.dygraph.base.to_variable(x)
-                ...         tmp.stop_gradient=False
-                ...         inputs2.append(tmp)
-                ...     ret2 = paddle.add_n(inputs2)
-                ...     loss2 = paddle.sum(ret2)
-                ...     loss2.retain_grads()
-                ...     loss2.backward()
-                ...     print(loss2.gradient())
-                ...     loss2.clear_gradient()
-                ...     print("After clear {}".format(loss2.gradient()))
+                >>> inputs2 = []
+                >>> for _ in range(10):
+                >>>     tmp = base.dygraph.base.to_variable(x)
+                >>>     tmp.stop_gradient=False
+                >>>     inputs2.append(tmp)
+                >>> ret2 = paddle.add_n(inputs2)
+                >>> loss2 = paddle.sum(ret2)
+                >>> loss2.retain_grads()
+                >>> loss2.backward()
+                >>> print(loss2.gradient())
+                >>> loss2.clear_gradient()
+                >>> print("After clear {}".format(loss2.gradient()))
                 1.0
                 After clear 0.0
         """

python/paddle/jit/dy2static/convert_operators.py

@@ -39,7 +39,11 @@
 
 
 def convert_attr(x, attr):
-    if isinstance(x, (Variable, OpResult)) and attr == "size":
+    # TODO(cleanup-legacy-ir): In PIR mode, the size attr in
+    # OpResult and Tensor are unified. So we don't need to transform
+    # the size attr into a method call. The AttributeJstTransformer and
+    # convert_attr can be safely removed.
+    if isinstance(x, Variable) and attr == "size":
         return x.size()
     else:
         return getattr(x, attr)

python/paddle/jit/sot/infer_meta.py

@@ -105,7 +105,7 @@ class VariableCreator:
     """
 
     def __init__(self):
-        # TODO(dev): Remove the program and var_cache shims after PIR become default state.
+        # TODO(cleanup-legacy-ir): Remove the program and var_cache shims after PIR become default state.
         # self.var_cache = {}
         # self.main_program = paddle.static.Program()
         # self.startup_program = paddle.static.Program()

python/paddle/pir/math_op_patch.py

@@ -16,6 +16,7 @@
 import warnings
 
 from paddle.base.libpaddle import DataType
+from paddle.base.wrapped_decorator import wrap_decorator
 
 from . import OpResult
 
@@ -31,6 +32,21 @@
 ]
 
 
+def _fake_interface_only_(func):
+    def __impl__(*args, **kwargs):
+        raise AssertionError(
+            f"'{func.__name__}' only can be called by `paddle.Tensor` in dynamic graph mode. Suggestions:\n"
+            "  1. If you are in static graph mode, you can switch to dynamic graph mode by turning off `paddle.enable_static()` or calling `paddle.disable_static()`.\n"
+            "  2. If you are using `@paddle.jit.to_static`, you can call `paddle.jit.enable_to_static(False)`. "
+            f"If you have to translate dynamic graph to static graph, please use other API to replace '{func.__name__}'."
+        )
+
+    return __impl__
+
+
+fake_interface_only = wrap_decorator(_fake_interface_only_)
+
+
 def create_tensor_with_batchsize(ref_var, value, dtype):
     assert isinstance(ref_var, OpResult)
     value = float(value)
@@ -356,6 +372,43 @@ def clone(self):
         """
         return paddle.assign(self)
 
+    @fake_interface_only
+    def clear_gradient(self):
+        """
+        **Notes**:
+            **1. This API is ONLY available in Dygraph mode**
+
+            **2. Use it only OpResult has gradient, normally we use this for Parameters since other temporal OpResult will be deleted by Python's GC**
+
+        Clear  (set to ``0`` ) the Gradient of Current OpResult
+
+        Returns:  None
+
+        Examples:
+            .. code-block:: python
+
+                >>> import paddle
+                >>> import paddle.base as base
+                >>> import numpy as np
+
+                >>> x = np.ones([2, 2], np.float32)
+                >>> inputs2 = []
+                >>> for _ in range(10):
+                >>>     tmp = base.dygraph.base.to_variable(x)
+                >>>     tmp.stop_gradient=False
+                >>>     inputs2.append(tmp)
+                >>> ret2 = paddle.add_n(inputs2)
+                >>> loss2 = paddle.sum(ret2)
+                >>> loss2.retain_grads()
+                >>> loss2.backward()
+                >>> print(loss2.gradient())
+                >>> loss2.clear_gradient()
+                >>> print("After clear {}".format(loss2.gradient()))
+                1.0
+                After clear 0.0
+        """
+        pass
+
     def append(self, var):
         """
         **Notes**:
@@ -383,6 +436,7 @@ def append(self, var):
         ('astype', astype),
         ('size', _size_),
         ('clone', clone),
+        ('clear_gradient', clear_gradient),
         ('append', append),
         (
             '__add__',

test/dygraph_to_static/dygraph_to_static_utils.py

@@ -398,6 +398,12 @@ def test_default_mode_only(fn):
     return fn
 
 
+def test_sot_with_pir_only(fn):
+    fn = set_to_static_mode(ToStaticMode.SOT)(fn)
+    fn = set_ir_mode(IrMode.PIR)(fn)
+    return fn
+
+
 # NOTE: This is a special decorator for comparing legacy and pt
 def compare_legacy_with_pt(fn):
     @wraps(fn)

test/dygraph_to_static/test_for_enumerate.py

@@ -424,6 +424,7 @@ def set_input(self):
     def set_test_func(self):
         self.dygraph_func = for_iter_var_numpy
 
+    @test_legacy_and_pt_and_pir
     def test_transformed_result_compare(self):
         self.set_test_func()
         self.transformed_result_compare()
@@ -478,6 +479,11 @@ class TestForEnumerateVarWithNestedRange(TestForIterVarNumpy):
     def set_test_func(self):
         self.dygraph_func = for_enumerate_var_with_nested_range
 
+    # Remove this if we support control flow
+    def test_transformed_result_compare(self):
+        self.set_test_func()
+        self.transformed_result_compare()
+
 
 class TestForIterVarList(TestForInRange):
     def set_test_func(self):

test/dygraph_to_static/test_mnist.py

@@ -21,6 +21,7 @@
 from dygraph_to_static_utils import (
     Dy2StTestBase,
     test_default_mode_only,
+    test_sot_with_pir_only,
 )
 from predictor_utils import PredictorTools
 
@@ -34,8 +35,8 @@
 
 SEED = 2020
 
-if paddle.base.is_compiled_with_cuda():
-    paddle.base.set_flags({'FLAGS_cudnn_deterministic': True})
+if paddle.is_compiled_with_cuda():
+    paddle.set_flags({'FLAGS_cudnn_deterministic': True})
 
 
 class SimpleImgConvPool(paddle.nn.Layer):
@@ -134,9 +135,9 @@ def setUp(self):
         self.epoch_num = 1
         self.batch_size = 64
         self.place = (
-            base.CUDAPlace(0)
-            if base.is_compiled_with_cuda()
-            else base.CPUPlace()
+            paddle.CUDAPlace(0)
+            if paddle.is_compiled_with_cuda()
+            else paddle.CPUPlace()
         )
         self.train_reader = paddle.batch(
             paddle.dataset.mnist.train(),
@@ -173,14 +174,14 @@ def test_mnist_to_static(self):
             err_msg=f'dygraph is {dygraph_loss}\n static_res is \n{static_loss}',
         )
 
-    @test_default_mode_only
+    @test_sot_with_pir_only
     def test_mnist_declarative_cpu_vs_mkldnn(self):
         dygraph_loss_cpu = self.train_dygraph()
-        base.set_flags({'FLAGS_use_mkldnn': True})
+        paddle.set_flags({'FLAGS_use_mkldnn': True})
         try:
             dygraph_loss_mkldnn = self.train_dygraph()
         finally:
-            base.set_flags({'FLAGS_use_mkldnn': False})
+            paddle.set_flags({'FLAGS_use_mkldnn': False})
         np.testing.assert_allclose(
             dygraph_loss_cpu,
             dygraph_loss_mkldnn,
@@ -192,62 +193,61 @@ def test_mnist_declarative_cpu_vs_mkldnn(self):
 
     def train(self, to_static=False):
         loss_data = []
-        with base.dygraph.guard(self.place):
-            base.default_main_program().random_seed = SEED
-            base.default_startup_program().random_seed = SEED
-            mnist = MNIST()
-            if to_static:
-                mnist = paddle.jit.to_static(mnist, full_graph=True)
-            adam = Adam(learning_rate=0.001, parameters=mnist.parameters())
-
-            for epoch in range(self.epoch_num):
-                start = time()
-                for batch_id, data in enumerate(self.train_reader()):
-                    dy_x_data = np.array(
-                        [x[0].reshape(1, 28, 28) for x in data]
-                    ).astype('float32')
-                    y_data = (
-                        np.array([x[1] for x in data])
-                        .astype('int64')
-                        .reshape(-1, 1)
-                    )
-
-                    img = to_variable(dy_x_data)
-                    label = to_variable(y_data)
-
-                    label.stop_gradient = True
-                    prediction, acc, avg_loss = mnist(img, label=label)
-                    avg_loss.backward()
+        base.default_main_program().random_seed = SEED
+        base.default_startup_program().random_seed = SEED
+        mnist = MNIST()
+        if to_static:
+            mnist = paddle.jit.to_static(mnist, full_graph=True)
+        adam = Adam(learning_rate=0.001, parameters=mnist.parameters())
+
+        for epoch in range(self.epoch_num):
+            start = time()
+            for batch_id, data in enumerate(self.train_reader()):
+                dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]
+                ).astype('float32')
+                y_data = (
+                    np.array([x[1] for x in data])
+                    .astype('int64')
+                    .reshape(-1, 1)
+                )
 
-                    adam.minimize(avg_loss)
-                    loss_data.append(float(avg_loss))
-                    # save checkpoint
-                    mnist.clear_gradients()
-                    if batch_id % 10 == 0:
-                        print(
-                            "Loss at epoch {} step {}: loss: {:}, acc: {}, cost: {}".format(
-                                epoch,
-                                batch_id,
-                                avg_loss.numpy(),
-                                acc.numpy(),
-                                time() - start,
-                            )
-                        )
-                        start = time()
-                    if batch_id == 50:
-                        mnist.eval()
-                        prediction, acc, avg_loss = mnist(img, label)
-                        loss_data.append(float(avg_loss))
-                        # new save load check
-                        self.check_jit_save_load(
-                            mnist,
-                            [dy_x_data],
-                            [img, label],
-                            to_static,
-                            prediction,
-                            [img.name],
+                img = to_variable(dy_x_data)
+                label = to_variable(y_data)
+
+                label.stop_gradient = True
+                prediction, acc, avg_loss = mnist(img, label=label)
+                avg_loss.backward()
+
+                adam.minimize(avg_loss)
+                loss_data.append(float(avg_loss))
+                # save checkpoint
+                mnist.clear_gradients()
+                if batch_id % 10 == 0:
+                    print(
+                        "Loss at epoch {} step {}: loss: {:}, acc: {}, cost: {}".format(
+                            epoch,
+                            batch_id,
+                            avg_loss.numpy(),
+                            acc.numpy(),
+                            time() - start,
                         )
-                        break
+                    )
+                    start = time()
+                if batch_id == 50:
+                    mnist.eval()
+                    prediction, acc, avg_loss = mnist(img, label)
+                    loss_data.append(float(avg_loss))
+                    # new save load check
+                    self.check_jit_save_load(
+                        mnist,
+                        [dy_x_data],
+                        [img, label],
+                        to_static,
+                        prediction,
+                        [img.name],
+                    )
+                    break
         return loss_data
 
     def check_jit_save_load(