PaddlePaddle
diff --git a/‎test/xpu/test_set_value_op_xpu.py
Copy file name to clipboard
+168-160Lines changed: 168 additions & 160 deletions b/‎test/xpu/test_set_value_op_xpu.py
Copy file name to clipboard
+168-160Lines changed: 168 additions & 160 deletions
diff --git a/‎test/xpu/test_swiglu_op_xpu.py
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎test/xpu/test_swiglu_op_xpu.py
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎test/xpu/test_tril_triu_op_xpu.py
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎test/xpu/test_tril_triu_op_xpu.py
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
@@ -1183,13 +1183,19 @@ def test_static(self):
             exe = paddle.static.Executor(self.place)
             exe.run(startup_program)
 
-            var_grad, z_grad = exe.run(
-                main_program,
-                feed={"x": x_np, "y": y_np, "label": label_np},
-                fetch_list=[var.name + "@GRAD", z.name + "@GRAD"],
-            )
-
-            self.assertTrue((var_grad == z_grad[0, :]).all())
+            if paddle.framework.use_pir_api():
+                exe.run(
+                    main_program,
+                    feed={"x": x_np, "y": y_np, "label": label_np},
+                    fetch_list=[],
+                )
+            else:
+                var_grad, z_grad = exe.run(
+                    main_program,
+                    feed={"x": x_np, "y": y_np, "label": label_np},
+                    fetch_list=[var.name + "@GRAD", z.name + "@GRAD"],
+                )
+                self.assertTrue((var_grad == z_grad[0, :]).all())
             paddle.disable_static()
 
     class XPUTestGradientTruncated(XPUOpTest):
@@ -1445,174 +1451,176 @@ def set_value5(t, value):
 
         def test_static_graph(self):
             paddle.enable_static()
-
-            to_string = lambda x, i: x + '_' + str(i)
-            numel = lambda input_shape: reduce(
-                lambda x, y: x * y, input_shape, 1
-            )
-
-            def op1(x):
-                value = paddle.tensor.fill_constant([1], "float32", 1)
-                # test stop_gradient
-                value.stop_gradient = True
-                x.stop_gradient = False
-                start = paddle.tensor.fill_constant(
-                    [1], "int32", 5, force_cpu=True
-                )
-                end = paddle.tensor.fill_constant(
-                    [1], "int32", 0, force_cpu=True
-                )
-                step = paddle.tensor.fill_constant(
-                    [1], "int32", -2, force_cpu=True
+            with paddle.pir_utils.OldIrGuard():
+                to_string = lambda x, i: x + '_' + str(i)
+                numel = lambda input_shape: reduce(
+                    lambda x, y: x * y, input_shape, 1
                 )
 
-                inputs = {
-                    'Input': x,
-                    'ValueTensor': value,
-                    'StartsTensorList': [
-                        start,
-                    ],
-                    'EndsTensorList': [
-                        end,
-                    ],
-                    'StepsTensorList': [
-                        step,
-                    ],
-                }
-
-                helper = LayerHelper("set_value")
-                y = helper.create_variable_for_type_inference(dtype=x.dtype)
+                def op1(x):
+                    value = paddle.tensor.fill_constant([1], "float32", 1)
+                    # test stop_gradient
+                    value.stop_gradient = True
+                    x.stop_gradient = False
+                    start = paddle.tensor.fill_constant(
+                        [1], "int32", 5, force_cpu=True
+                    )
+                    end = paddle.tensor.fill_constant(
+                        [1], "int32", 0, force_cpu=True
+                    )
+                    step = paddle.tensor.fill_constant(
+                        [1], "int32", -2, force_cpu=True
+                    )
 
-                helper.append_op(
-                    type="set_value",
-                    inputs=inputs,
-                    outputs={'Out': y},
-                    attrs={'axes': [0]},
-                )
+                    inputs = {
+                        'Input': x,
+                        'ValueTensor': value,
+                        'StartsTensorList': [
+                            start,
+                        ],
+                        'EndsTensorList': [
+                            end,
+                        ],
+                        'StepsTensorList': [
+                            step,
+                        ],
+                    }
 
-                return y, value
+                    helper = LayerHelper("set_value")
+                    y = helper.create_variable_for_type_inference(dtype=x.dtype)
 
-            def op2(x):
-                value = paddle.tensor.fill_constant([1, 3, 2], "float32", 1)
-                # test stop_gradient
-                value.stop_gradient = False
-                x.stop_gradient = False
-                attrs = {
-                    'axes': [0],
-                    'starts': [6],
-                    'ends': [0],
-                    'steps': [-4],
-                    'decrease_axes': [],
-                    'none_axes': [],
-                    'dtype': paddle.float32,
-                }
-                inputs = {'Input': x, 'ValueTensor': value}
-
-                helper = LayerHelper("set_value")
-                y = helper.create_variable_for_type_inference(dtype=x.dtype)
-
-                helper.append_op(
-                    type="set_value",
-                    inputs=inputs,
-                    outputs={'Out': y},
-                    attrs=attrs,
-                )
-
-                return y, value
+                    helper.append_op(
+                        type="set_value",
+                        inputs=inputs,
+                        outputs={'Out': y},
+                        attrs={'axes': [0]},
+                    )
 
-            def op3(x):
-                value = paddle.tensor.fill_constant([1], "float32", 1)
-                x.stop_gradient = True
-                value.stop_gradient = False
-                start = paddle.tensor.fill_constant(
-                    [1], "int32", 0, force_cpu=True
-                )
-                end = paddle.tensor.fill_constant(
-                    [1], "int32", 5, force_cpu=True
-                )
-                step = paddle.tensor.fill_constant(
-                    [1], "int32", 3, force_cpu=True
-                )
+                    return y, value
+
+                def op2(x):
+                    value = paddle.tensor.fill_constant([1, 3, 2], "float32", 1)
+                    # test stop_gradient
+                    value.stop_gradient = False
+                    x.stop_gradient = False
+                    attrs = {
+                        'axes': [0],
+                        'starts': [6],
+                        'ends': [0],
+                        'steps': [-4],
+                        'decrease_axes': [],
+                        'none_axes': [],
+                        'dtype': paddle.float32,
+                    }
+                    inputs = {'Input': x, 'ValueTensor': value}
+
+                    helper = LayerHelper("set_value")
+                    y = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+                    helper.append_op(
+                        type="set_value",
+                        inputs=inputs,
+                        outputs={'Out': y},
+                        attrs=attrs,
+                    )
 
-                inputs = {
-                    'Input': x,
-                    'ValueTensor': value,
-                    'StartsTensorList': [
-                        start,
-                    ],
-                    'EndsTensorList': [
-                        end,
-                    ],
-                    'StepsTensorList': [
-                        step,
-                    ],
-                }
+                    return y, value
 
-                helper = LayerHelper("set_value")
-                y = helper.create_variable_for_type_inference(dtype=x.dtype)
+                def op3(x):
+                    value = paddle.tensor.fill_constant([1], "float32", 1)
+                    x.stop_gradient = True
+                    value.stop_gradient = False
+                    start = paddle.tensor.fill_constant(
+                        [1], "int32", 0, force_cpu=True
+                    )
+                    end = paddle.tensor.fill_constant(
+                        [1], "int32", 5, force_cpu=True
+                    )
+                    step = paddle.tensor.fill_constant(
+                        [1], "int32", 3, force_cpu=True
+                    )
 
-                helper.append_op(
-                    type="set_value",
-                    inputs=inputs,
-                    outputs={'Out': y},
-                    attrs={'axes': [0]},
-                )
+                    inputs = {
+                        'Input': x,
+                        'ValueTensor': value,
+                        'StartsTensorList': [
+                            start,
+                        ],
+                        'EndsTensorList': [
+                            end,
+                        ],
+                        'StepsTensorList': [
+                            step,
+                        ],
+                    }
 
-                return y, value
+                    helper = LayerHelper("set_value")
+                    y = helper.create_variable_for_type_inference(dtype=x.dtype)
 
-            def set_value(array, i, op):
-                name_x = to_string('x', i)
-                x = paddle.static.data(
-                    name=name_x, shape=array.shape, dtype='float32'
-                )
+                    helper.append_op(
+                        type="set_value",
+                        inputs=inputs,
+                        outputs={'Out': y},
+                        attrs={'axes': [0]},
+                    )
 
-                # set_value_op in __get/setitem__ is an inplace operation.
-                # When `input.stop_gradient = True` and `value.stop_gradient = False`,
-                # set_value_grad_op will not be run during backward.
-                y, value = op(x)
-                y2 = y + 1
-                loss = paddle.sum(y2)
-                sgd = paddle.optimizer.Adam()
-                sgd.minimize(loss)
-                place = self.place
-
-                prog = paddle.static.default_main_program()
-                exe = paddle.static.Executor(place)
-                exe.run(paddle.static.default_startup_program())
-                fetch_list = []
-                if not x.stop_gradient:
-                    fetch_list.append(x.grad_name)
-                if not value.stop_gradient:
-                    fetch_list.append(value.grad_name)
-                out = exe.run(prog, feed={x.name: array}, fetch_list=fetch_list)
-                return out
-
-            input_shape = [7, 6, 5, 4, 3, 2]
-
-            array = np.arange(0, numel(input_shape), dtype="float32").reshape(
-                input_shape
-            )
+                    return y, value
 
-            for i in range(len(input_shape)):
-                program = paddle.static.Program()
-                with paddle.static.program_guard(program):
-                    out1 = set_value(array, i, op1)
-                    self.assertTrue((out1[0][5:0:-2] == 0).all())
-
-                if len(array.shape) > 2:
-                    program2 = paddle.static.Program()
-                    with paddle.static.program_guard(program2):
-                        out2 = set_value(array, i, op2)
-                        self.assertTrue((out2[0][6:0:-4] == 0).all())
-
-                program3 = paddle.static.Program()
-                with paddle.static.program_guard(program3):
-                    out3 = set_value(array, i, op3)
-                    self.assertTrue(
-                        (numel(out1[0][0:5:3].shape) == out3[0]).all()
+                def set_value(array, i, op):
+                    name_x = to_string('x', i)
+                    x = paddle.static.data(
+                        name=name_x, shape=array.shape, dtype='float32'
                     )
 
-                array = array[0]
+                    # set_value_op in __get/setitem__ is an inplace operation.
+                    # When `input.stop_gradient = True` and `value.stop_gradient = False`,
+                    # set_value_grad_op will not be run during backward.
+                    y, value = op(x)
+                    y2 = y + 1
+                    loss = paddle.sum(y2)
+                    sgd = paddle.optimizer.Adam()
+                    sgd.minimize(loss)
+                    place = self.place
+
+                    prog = paddle.static.default_main_program()
+                    exe = paddle.static.Executor(place)
+                    exe.run(paddle.static.default_startup_program())
+                    fetch_list = []
+                    if not x.stop_gradient:
+                        fetch_list.append(x.grad_name)
+                    if not value.stop_gradient:
+                        fetch_list.append(value.grad_name)
+                    out = exe.run(
+                        prog, feed={x.name: array}, fetch_list=fetch_list
+                    )
+                    return out
+
+                input_shape = [7, 6, 5, 4, 3, 2]
+
+                array = np.arange(
+                    0, numel(input_shape), dtype="float32"
+                ).reshape(input_shape)
+
+                for i in range(len(input_shape)):
+                    program = paddle.static.Program()
+                    with paddle.static.program_guard(program):
+                        out1 = set_value(array, i, op1)
+                        self.assertTrue((out1[0][5:0:-2] == 0).all())
+
+                    if len(array.shape) > 2:
+                        program2 = paddle.static.Program()
+                        with paddle.static.program_guard(program2):
+                            out2 = set_value(array, i, op2)
+                            self.assertTrue((out2[0][6:0:-4] == 0).all())
+
+                    program3 = paddle.static.Program()
+                    with paddle.static.program_guard(program3):
+                        out3 = set_value(array, i, op3)
+                        self.assertTrue(
+                            (numel(out1[0][0:5:3].shape) == out3[0]).all()
+                        )
+
+                    array = array[0]
             paddle.disable_static()
 
     class XPUTestSetValueInplace(XPUOpTest):
 
@@ -147,7 +147,7 @@ def check_static_graph(self, shape, dtype="float32"):
             feed={'x': x_np, 'y': y_np, 'concated_x': concated_x_np},
             fetch_list=[out1, out2],
         )
-        np.testing.assert_equal(out1, out2)
+        np.testing.assert_equal(t1, t2)
 
     def check_main(self, shape):
         self.check_dygraph(shape)
 
@@ -131,6 +131,8 @@ def initTestCase(self):
 class TestTrilTriuOpError(unittest.TestCase):
     def test_errors1(self):
         paddle.enable_static()
+        if paddle.framework.use_pir_api():
+            return
         data = paddle.static.data(shape=(20, 22), dtype='float32', name="data1")
         op_type = np.random.choice(['triu', 'tril'])
         errmsg = {
@@ -144,6 +146,8 @@ def test_errors1(self):
 
     def test_errors2(self):
         paddle.enable_static()
+        if paddle.framework.use_pir_api():
+            return
         data = paddle.static.data(shape=(200,), dtype='float32', name="data2")
         op_type = np.random.choice(['triu', 'tril'])
         errmsg = {
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ def check_static_graph(self, shape, dtype="float32"):`
`147`	`147`	`feed={'x': x_np, 'y': y_np, 'concated_x': concated_x_np},`
`148`	`148`	`fetch_list=[out1, out2],`
`149`	`149`	`)`
`150`		`- np.testing.assert_equal(out1, out2)`
	`150`	`+ np.testing.assert_equal(t1, t2)`
`151`	`151`
`152`	`152`	`def check_main(self, shape):`
`153`	`153`	`self.check_dygraph(shape)`