PaddlePaddle
diff --git a/‎test/xpu/op_test_xpu.py
Copy file name to clipboard
+133-128Lines changed: 133 additions & 128 deletions b/‎test/xpu/op_test_xpu.py
Copy file name to clipboard
+133-128Lines changed: 133 additions & 128 deletions
diff --git a/‎test/xpu/test_clip_op_xpu.py
Copy file name to clipboard
+53-42Lines changed: 53 additions & 42 deletions b/‎test/xpu/test_clip_op_xpu.py
Copy file name to clipboard
+53-42Lines changed: 53 additions & 42 deletions
diff --git a/‎test/xpu/test_diag_v2_op_xpu.py
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎test/xpu/test_diag_v2_op_xpu.py
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
@@ -271,141 +271,146 @@ def get_grad_with_place(
         user_defined_grad_outputs=None,
         check_dygraph=False,
     ):
-        self.scope = core.Scope()
-        op_inputs = self.inputs if hasattr(self, "inputs") else {}
-        op_outputs = self.outputs if hasattr(self, "outputs") else {}
-        op_attrs = self.attrs if hasattr(self, "attrs") else {}
-
-        self._check_grad_helper()
-        if (
-            self.dtype == np.float64
-            and self.op_type
-            not in op_threshold_white_list.NEED_FIX_FP64_CHECK_GRAD_THRESHOLD_OP_LIST
-        ):
-            numeric_grad_delta = 1e-5
-            max_relative_error = 1e-7
-
-        cache_list = None
-        if hasattr(self, "cache_name_list"):
-            cache_list = self.cache_name_list
-
-        # oneDNN numeric gradient should use CPU kernel
-        use_onednn = False
-        if "use_mkldnn" in op_attrs and op_attrs["use_mkldnn"]:
-            op_attrs["use_mkldnn"] = False
-            use_onednn = True
-
-        mean_grad_op_types = get_xpu_op_support_types('mean')
-        mean_grad_op_types_np = []
-        for mtype in mean_grad_op_types:
-            mean_grad_op_types_np.append(type_dict_str_to_numpy[mtype])
-
-        self.op = create_op(
-            self.scope,
-            self.op_type,
-            op_inputs,
-            op_outputs,
-            op_attrs,
-            cache_list=cache_list,
-        )
-
-        if use_onednn:
-            op_attrs["use_mkldnn"] = True
+        with paddle.pir_utils.OldIrGuard():
+            self.scope = core.Scope()
+            op_inputs = self.inputs if hasattr(self, "inputs") else {}
+            op_outputs = self.outputs if hasattr(self, "outputs") else {}
+            op_attrs = self.attrs if hasattr(self, "attrs") else {}
 
-        if no_grad_set is None:
-            no_grad_set = set()
-        else:
+            self._check_grad_helper()
             if (
-                (self.op_type not in no_grad_set_white_list.NEED_TO_FIX_OP_LIST)
-                and (
-                    self.op_type not in no_grad_set_white_list.NOT_CHECK_OP_LIST
-                )
-                and (not self.is_bfloat16_op())
+                self.dtype == np.float64
+                and self.op_type
+                not in op_threshold_white_list.NEED_FIX_FP64_CHECK_GRAD_THRESHOLD_OP_LIST
             ):
-                raise AssertionError(
-                    "no_grad_set must be None, op_type is "
-                    + self.op_type
-                    + " Op."
-                )
-
-        for input_to_check in inputs_to_check:
-            set_input(self.scope, self.op, self.inputs, place)
-
-        if type(output_names) is not list:
-            output_names = [output_names]
-
-        if self.dtype not in mean_grad_op_types_np:
-            prog = Program()
-            block = prog.global_block()
-            scope = core.Scope()
-            self._append_ops(block)
-
-            inputs = self._get_inputs(block)
-            outputs = self._get_outputs(block)
-            feed_dict = self.feed_var(inputs, place)
-            cast_inputs = list(map(block.var, output_names))
-            cast_outputs = block.create_var(
-                dtype="float32", shape=cast_inputs[0].shape
+                numeric_grad_delta = 1e-5
+                max_relative_error = 1e-7
+
+            cache_list = None
+            if hasattr(self, "cache_name_list"):
+                cache_list = self.cache_name_list
+
+            # oneDNN numeric gradient should use CPU kernel
+            use_onednn = False
+            if "use_mkldnn" in op_attrs and op_attrs["use_mkldnn"]:
+                op_attrs["use_mkldnn"] = False
+                use_onednn = True
+
+            mean_grad_op_types = get_xpu_op_support_types('mean')
+            mean_grad_op_types_np = []
+            for mtype in mean_grad_op_types:
+                mean_grad_op_types_np.append(type_dict_str_to_numpy[mtype])
+
+            self.op = create_op(
+                self.scope,
+                self.op_type,
+                op_inputs,
+                op_outputs,
+                op_attrs,
+                cache_list=cache_list,
             )
-            cast_op = block.append_op(
-                type="cast",
-                inputs={"X": cast_inputs},
-                outputs={"Out": cast_outputs},
-                attrs={
-                    "in_dtype": convert_np_dtype_to_dtype_(self.dtype),
-                    "out_dtype": core.VarDesc.VarType.FP32,
-                },
-            )
-            cast_op.desc.infer_var_type(block.desc)
-            cast_op.desc.infer_shape(block.desc)
 
-            output_names = [cast_outputs.name]
+            if use_onednn:
+                op_attrs["use_mkldnn"] = True
+
+            if no_grad_set is None:
+                no_grad_set = set()
+            else:
+                if (
+                    (
+                        self.op_type
+                        not in no_grad_set_white_list.NEED_TO_FIX_OP_LIST
+                    )
+                    and (
+                        self.op_type
+                        not in no_grad_set_white_list.NOT_CHECK_OP_LIST
+                    )
+                    and (not self.is_bfloat16_op())
+                ):
+                    raise AssertionError(
+                        "no_grad_set must be None, op_type is "
+                        + self.op_type
+                        + " Op."
+                    )
+
+            for input_to_check in inputs_to_check:
+                set_input(self.scope, self.op, self.inputs, place)
+
+            if type(output_names) is not list:
+                output_names = [output_names]
+
+            if self.dtype not in mean_grad_op_types_np:
+                prog = Program()
+                block = prog.global_block()
+                scope = core.Scope()
+                self._append_ops(block)
+
+                inputs = self._get_inputs(block)
+                outputs = self._get_outputs(block)
+                feed_dict = self.feed_var(inputs, place)
+                cast_inputs = list(map(block.var, output_names))
+                cast_outputs = block.create_var(
+                    dtype="float32", shape=cast_inputs[0].shape
+                )
+                cast_op = block.append_op(
+                    type="cast",
+                    inputs={"X": cast_inputs},
+                    outputs={"Out": cast_outputs},
+                    attrs={
+                        "in_dtype": convert_np_dtype_to_dtype_(self.dtype),
+                        "out_dtype": core.VarDesc.VarType.FP32,
+                    },
+                )
+                cast_op.desc.infer_var_type(block.desc)
+                cast_op.desc.infer_shape(block.desc)
 
-            loss = append_loss_ops(block, output_names)
-            loss_names = [loss.name]
-            recast_inputs = list(map(block.var, loss_names))
-            recast_loss = block.create_var(
-                dtype=self.dtype, shape=recast_inputs[0].shape
-            )
+                output_names = [cast_outputs.name]
 
-            recast_op = block.append_op(
-                type="cast",
-                inputs={"X": recast_inputs},
-                outputs={"Out": recast_loss},
-                attrs={
-                    "in_dtype": core.VarDesc.VarType.FP32,
-                    "out_dtype": convert_np_dtype_to_dtype_(self.dtype),
-                },
-            )
-            recast_op.desc.infer_var_type(block.desc)
-            recast_op.desc.infer_shape(block.desc)
+                loss = append_loss_ops(block, output_names)
+                loss_names = [loss.name]
+                recast_inputs = list(map(block.var, loss_names))
+                recast_loss = block.create_var(
+                    dtype=self.dtype, shape=recast_inputs[0].shape
+                )
 
-            param_grad_list = append_backward(
-                loss=recast_loss,
-                parameter_list=[input_to_check],
-                no_grad_set=no_grad_set,
-            )
-            fetch_list = [g for p, g in param_grad_list]
-
-            executor = base.Executor(place)
-            return list(
-                map(
-                    np.array,
-                    executor.run(
-                        prog,
-                        feed_dict,
-                        fetch_list,
-                        scope=scope,
-                        return_numpy=False,
-                    ),
+                recast_op = block.append_op(
+                    type="cast",
+                    inputs={"X": recast_inputs},
+                    outputs={"Out": recast_loss},
+                    attrs={
+                        "in_dtype": core.VarDesc.VarType.FP32,
+                        "out_dtype": convert_np_dtype_to_dtype_(self.dtype),
+                    },
                 )
-            )
+                recast_op.desc.infer_var_type(block.desc)
+                recast_op.desc.infer_shape(block.desc)
 
-        analytic_grads = self._get_gradient(
-            inputs_to_check,
-            place,
-            output_names,
-            no_grad_set,
-            user_defined_grad_outputs=user_defined_grad_outputs,
-        )
-        return analytic_grads
+                param_grad_list = append_backward(
+                    loss=recast_loss,
+                    parameter_list=[input_to_check],
+                    no_grad_set=no_grad_set,
+                )
+                fetch_list = [g for p, g in param_grad_list]
+
+                executor = base.Executor(place)
+                return list(
+                    map(
+                        np.array,
+                        executor.run(
+                            prog,
+                            feed_dict,
+                            fetch_list,
+                            scope=scope,
+                            return_numpy=False,
+                        ),
+                    )
+                )
+
+            analytic_grads = self._get_gradient(
+                inputs_to_check,
+                place,
+                output_names,
+                no_grad_set,
+                user_defined_grad_outputs=user_defined_grad_outputs,
+            )
+            return analytic_grads
@@ -150,48 +150,59 @@ def _executed_api(self, x, min=None, max=None):
 
     def test_clip(self):
         paddle.enable_static()
-        data_shape = [1, 9, 9, 4]
-        data = np.random.random(data_shape).astype('float32')
-        images = paddle.static.data(
-            name='image', shape=data_shape, dtype='float32'
-        )
-        min = paddle.static.data(name='min', shape=[1], dtype='float32')
-        max = paddle.static.data(name='max', shape=[1], dtype='float32')
-
-        place = (
-            base.XPUPlace(0)
-            if base.core.is_compiled_with_xpu()
-            else base.CPUPlace()
-        )
-        exe = base.Executor(place)
-
-        out_1 = self._executed_api(images, min=min, max=max)
-        out_2 = self._executed_api(images, min=0.2, max=0.9)
-        out_3 = self._executed_api(images, min=0.3)
-        out_4 = self._executed_api(images, max=0.7)
-        out_5 = self._executed_api(images, min=min)
-        out_6 = self._executed_api(images, max=max)
-        out_7 = self._executed_api(images, max=-1.0)
-        out_8 = self._executed_api(images)
-
-        res1, res2, res3, res4, res5, res6, res7, res8 = exe.run(
-            base.default_main_program(),
-            feed={
-                "image": data,
-                "min": np.array([0.2]).astype('float32'),
-                "max": np.array([0.8]).astype('float32'),
-            },
-            fetch_list=[out_1, out_2, out_3, out_4, out_5, out_6, out_7, out_8],
-        )
-
-        np.testing.assert_allclose(res1, data.clip(0.2, 0.8))
-        np.testing.assert_allclose(res2, data.clip(0.2, 0.9))
-        np.testing.assert_allclose(res3, data.clip(min=0.3))
-        np.testing.assert_allclose(res4, data.clip(max=0.7))
-        np.testing.assert_allclose(res5, data.clip(min=0.2))
-        np.testing.assert_allclose(res6, data.clip(max=0.8))
-        np.testing.assert_allclose(res7, data.clip(max=-1))
-        np.testing.assert_allclose(res8, data)
+        train_prog = paddle.static.Program()
+        startup = paddle.static.Program()
+        with paddle.static.program_guard(train_prog, startup):
+            data_shape = [1, 9, 9, 4]
+            data = np.random.random(data_shape).astype('float32')
+            images = paddle.static.data(
+                name='image', shape=data_shape, dtype='float32'
+            )
+            min = paddle.static.data(name='min', shape=[1], dtype='float32')
+            max = paddle.static.data(name='max', shape=[1], dtype='float32')
+
+            place = (
+                base.XPUPlace(0)
+                if base.core.is_compiled_with_xpu()
+                else base.CPUPlace()
+            )
+            exe = base.Executor(place)
+
+            out_1 = self._executed_api(images, min=min, max=max)
+            out_2 = self._executed_api(images, min=0.2, max=0.9)
+            out_3 = self._executed_api(images, min=0.3)
+            out_4 = self._executed_api(images, max=0.7)
+            out_5 = self._executed_api(images, min=min)
+            out_6 = self._executed_api(images, max=max)
+            out_7 = self._executed_api(images, max=-1.0)
+            out_8 = self._executed_api(images)
+            res1, res2, res3, res4, res5, res6, res7, res8 = exe.run(
+                train_prog,
+                feed={
+                    "image": data,
+                    "min": np.array([0.2]).astype('float32'),
+                    "max": np.array([0.8]).astype('float32'),
+                },
+                fetch_list=[
+                    out_1,
+                    out_2,
+                    out_3,
+                    out_4,
+                    out_5,
+                    out_6,
+                    out_7,
+                    out_8,
+                ],
+            )
+
+            np.testing.assert_allclose(res1, data.clip(0.2, 0.8))
+            np.testing.assert_allclose(res2, data.clip(0.2, 0.9))
+            np.testing.assert_allclose(res3, data.clip(min=0.3))
+            np.testing.assert_allclose(res4, data.clip(max=0.7))
+            np.testing.assert_allclose(res5, data.clip(min=0.2))
+            np.testing.assert_allclose(res6, data.clip(max=0.8))
+            np.testing.assert_allclose(res7, data.clip(max=-1))
+            np.testing.assert_allclose(res8, data)
         paddle.disable_static()
 
     def test_clip_dygraph(self):
 
@@ -286,7 +286,8 @@ def run_static(self, use_gpu=False):
             np.testing.assert_allclose(res0, self.expected0, rtol=1e-05)
             np.testing.assert_allclose(res1, self.expected1, rtol=1e-05)
             np.testing.assert_allclose(res2, self.expected2, rtol=1e-05)
-            self.assertTrue('aaa' in result3.name)
+            if not paddle.framework.use_pir_api():
+                self.assertTrue('aaa' in result3.name)
             np.testing.assert_allclose(res4, self.expected3, rtol=1e-05)
             np.testing.assert_allclose(res5, self.expected4, rtol=1e-05)
             np.testing.assert_allclose(res6, self.expected5, rtol=1e-05)