suport pir in laplace, sequence_mask L1Decay (#60345)

YuanRisheng · web-flow · commit 3dd6eabe3566 · 2023-12-27T10:45:54.000+08:00
diff --git a/paddle/fluid/pir/dialect/op_generator/ops_api_gen.py b/paddle/fluid/pir/dialect/op_generator/ops_api_gen.py
@@ -100,7 +100,6 @@
     'self_dp_attention',
     'get_tensor_from_selected_rows',
     'print',
-    'sequence_mask',
     'number_count',
     'assign_value',
 ]
diff --git a/paddle/fluid/pybind/pir.cc b/paddle/fluid/pybind/pir.cc
@@ -614,15 +614,18 @@ pir::OpResult apply(Value self, py::object func) {
 }
 
 void BindValue(py::module *m) {
-  py::class_<Value> value(*m, "Value", R"DOC(
+  py::class_<Value> value(*m,
+                          "Value",
+                          R"DOC(
     Value class represents the SSA value in the IR system. It is a directed edge
     and a base class.
 
     Notes:
         The constructor of Value should not be invoked directly. Value can be automatically constructed
         when build network.
 
-  )DOC");
+  )DOC",
+                          pybind11::dynamic_attr());
   g_ir_value_pytype = reinterpret_cast<PyTypeObject *>(value.ptr());
   value.def(py::init<>())
       .def_property_readonly(
diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml
@@ -980,6 +980,15 @@
   intermediate : noise
   backward : rrelu_grad
 
+- op : sequence_mask
+  args: (Tensor x, Scalar(int) max_len, int out_dtype)
+  output: Tensor(y)
+  infer_meta:
+    func: SequenceMaskScalarInferMeta
+  kernel:
+    func: sequence_mask_scalar
+    data_type : x
+
 - op : set_value
   args : (Tensor x, IntArray starts, IntArray ends, IntArray steps, int64_t[] axes, int64_t[] decrease_axes, int64_t[] none_axes, int64_t[] shape, Scalar[] values)
   output : Tensor(out)
diff --git a/python/paddle/distribution/laplace.py b/python/paddle/distribution/laplace.py
@@ -54,12 +54,16 @@ class Laplace(distribution.Distribution):
     """
 
     def __init__(self, loc, scale):
-        if not isinstance(loc, (numbers.Real, framework.Variable)):
+        if not isinstance(
+            loc, (numbers.Real, framework.Variable, paddle.pir.Value)
+        ):
             raise TypeError(
                 f"Expected type of loc is Real|Variable, but got {type(loc)}"
             )
 
-        if not isinstance(scale, (numbers.Real, framework.Variable)):
+        if not isinstance(
+            scale, (numbers.Real, framework.Variable, paddle.pir.Value)
+        ):
             raise TypeError(
                 f"Expected type of scale is Real|Variable, but got {type(scale)}"
             )
diff --git a/python/paddle/nn/functional/extension.py b/python/paddle/nn/functional/extension.py
@@ -15,7 +15,7 @@
 # TODO: define the extention functions
 
 
-from paddle import _C_ops, _legacy_C_ops, in_dynamic_mode, tensor
+from paddle import _C_ops, tensor
 from paddle.utils import deprecated
 
 from ...base.data_feeder import check_type, check_variable_and_dtype
@@ -100,16 +100,11 @@ def sequence_mask(x, maxlen=None, dtype='int64', name=None):
 
     """
 
-    if in_dynamic_mode():
-        if not isinstance(dtype, core.VarDesc.VarType):
+    if in_dynamic_or_pir_mode():
+        if not isinstance(dtype, (core.VarDesc.VarType, core.DataType)):
             dtype = convert_np_dtype_to_dtype_(dtype)
         if maxlen is not None:
-            if isinstance(maxlen, core.eager.Tensor):
-                attrs = ('out_dtype', dtype)
-                out = _legacy_C_ops.sequence_mask(x, maxlen, *attrs)
-            else:
-                attrs = ('out_dtype', dtype, 'maxlen', maxlen)
-                out = _legacy_C_ops.sequence_mask(x, None, *attrs)
+            out = _C_ops.sequence_mask(x, maxlen, dtype)
             out.stop_gradient = True
             return out
 
diff --git a/python/paddle/pir/core.py b/python/paddle/pir/core.py
@@ -273,10 +273,13 @@ def create_parameter(
     name=None,
     **kwargs,
 ):
+    regularizer = None
     if 'initializer' not in kwargs:
         raise ValueError(
             "initializer is None, if you want to create parameter, please pass its initializer."
         )
+    if 'regularizer' in kwargs:
+        regularizer = kwargs['regularizer']
     if dtype is not None:
         if not isinstance(dtype, DataType):
             dtype = convert_np_dtype_to_dtype_(dtype)
@@ -302,6 +305,7 @@ def create_parameter(
         param.stop_gradient = not trainable
         param.persistable = True
 
+    param.regularizer = regularizer
     return param
 
 
diff --git a/python/paddle/tensor/random.py b/python/paddle/tensor/random.py
@@ -858,7 +858,7 @@ def uniform(shape, dtype=None, min=-1.0, max=1.0, seed=0, name=None):
                 )
             )
 
-    if not isinstance(dtype, core.VarDesc.VarType):
+    if not isinstance(dtype, (core.VarDesc.VarType, core.DataType)):
         dtype = convert_np_dtype_to_dtype_(dtype)
 
     if in_dynamic_mode():
diff --git a/test/distribution/parameterize.py b/test/distribution/parameterize.py
@@ -47,7 +47,7 @@ def decorate(cls):
     return decorate
 
 
-def parameterize_cls(fields, values=None):
+def parameterize_cls(fields, values=None, test_pir=False):
     fields = [fields] if isinstance(fields, str) else fields
     params = [dict(zip(fields, vals)) for vals in values]
 
@@ -56,10 +56,15 @@ def decorate(cls):
         for k, v in enumerate(params):
             test_cls = dict(cls.__dict__)
             test_cls.update(v)
+            test_cls["test_pir"] = False
             name = cls.__name__ + str(k)
             name = name + '.' + v.get('suffix') if v.get('suffix') else name
-
             test_cls_module[name] = type(name, (cls,), test_cls)
+            if test_pir:
+                name = name + ".pir"
+                test_cls["test_pir"] = True
+                pir_type = type(name, (cls,), test_cls)
+                test_cls_module[name] = pir_type
 
         for m in list(cls.__dict__):
             if m.startswith("test"):
diff --git a/test/distribution/test_distribution_laplace_static.py b/test/distribution/test_distribution_laplace_static.py
@@ -31,9 +31,10 @@
         ('one-dim', parameterize.xrand((2,)), parameterize.xrand((2,))),
         ('multi-dim', parameterize.xrand((5, 5)), parameterize.xrand((5, 5))),
     ],
+    test_pir=True,
 )
 class TestLaplace(unittest.TestCase):
-    def setUp(self):
+    def build_program(self):
         startup_program = paddle.static.Program()
         main_program = paddle.static.Program()
         executor = paddle.static.Executor(self.place)
@@ -61,6 +62,13 @@ def setUp(self):
             self.samples,
         ] = executor.run(main_program, feed=self.feeds, fetch_list=fetch_list)
 
+    def setUp(self):
+        if self.test_pir:
+            with paddle.pir_utils.IrGuard():
+                self.build_program()
+        else:
+            self.build_program()
+
     def test_mean(self):
         self.assertEqual(str(self.mean.dtype).split('.')[-1], self.scale.dtype)
         np.testing.assert_allclose(
@@ -155,9 +163,10 @@ def _np_entropy(self):
             np.array([[4.0, 6], [8, 2]]),
         ),
     ],
+    test_pir=True,
 )
 class TestLaplacePDF(unittest.TestCase):
-    def setUp(self):
+    def build_program(self):
         startup_program = paddle.static.Program()
         main_program = paddle.static.Program()
         executor = paddle.static.Executor(self.place)
@@ -183,6 +192,13 @@ def setUp(self):
             main_program, feed=self.feeds, fetch_list=fetch_list
         )
 
+    def setUp(self):
+        if self.test_pir:
+            with paddle.pir_utils.IrGuard():
+                self.build_program()
+        else:
+            self.build_program()
+
     def test_prob(self):
         np.testing.assert_allclose(
             self.prob,
@@ -228,9 +244,10 @@ def test_icdf(self):
             np.array([0.5]),
         )
     ],
+    test_pir=True,
 )
 class TestLaplaceAndLaplaceKL(unittest.TestCase):
-    def setUp(self):
+    def build_program(self):
         self.mp = paddle.static.Program()
         self.sp = paddle.static.Program()
         self.executor = paddle.static.Executor(self.place)
@@ -253,7 +270,14 @@ def setUp(self):
                 'scale2': self.scale2,
             }
 
-    def test_kl_divergence(self):
+    def setUp(self):
+        if self.test_pir:
+            with paddle.pir_utils.IrGuard():
+                self.build_program()
+        else:
+            self.build_program()
+
+    def add_kl_divergence(self):
         with paddle.static.program_guard(self.mp, self.sp):
             out = paddle.distribution.kl_divergence(self._dist_1, self._dist_2)
             self.executor.run(self.sp)
@@ -262,6 +286,13 @@ def test_kl_divergence(self):
             )
             np.testing.assert_allclose(out, self._np_kl(), atol=0, rtol=0.50)
 
+    def test_kl_divergence(self):
+        if self.test_pir:
+            with paddle.pir_utils.IrGuard():
+                self.add_kl_divergence()
+        else:
+            self.add_kl_divergence()
+
     def _np_kl(self):
         x = np.linspace(
             scipy.stats.laplace.ppf(0.01), scipy.stats.laplace.ppf(0.99), 1000
diff --git a/test/legacy_test/test_regularizer.py b/test/legacy_test/test_regularizer.py
@@ -111,6 +111,40 @@ def test_l2decay_regularizer(self):
         self.assertEqual(block.ops[-2].type, 'scale')
         self.assertEqual(block.ops[-3].type, 'sign')
 
+    def test_l1decay_regularizer(self):
+        with paddle.pir_utils.IrGuard():
+            main_program = paddle.static.Program()
+            with paddle.static.program_guard(main_program):
+                block = main_program.global_block()
+                mul_x = paddle.pir.core.create_parameter(
+                    dtype="float32",
+                    shape=[5, 10],
+                    name="mul.x",
+                    regularizer=regularizer.L1Decay(0.5),
+                    initializer=paddle.nn.initializer.Constant(1),
+                )
+                self.assertIsNotNone(mul_x.regularizer)
+                self.assertTrue(
+                    isinstance(mul_x.regularizer, regularizer.L1Decay)
+                )
+
+                mul_y = paddle.static.data(
+                    dtype="float32", shape=[10, 8], name="mul.y"
+                )
+                mul_out = paddle.matmul(mul_x, mul_y)
+                mean_out = paddle.mean(mul_out)
+                grads = paddle.autograd.ir_backward.grad(mean_out, [mul_x])
+                params_grads = [(mul_x, grads[0])]
+                self.assertEqual(len(params_grads), 1)
+                count_ops = len(block.ops)
+                optimizer = paddle.optimizer.Adam()
+                params_grads = optimizer.append_regularization_ops(params_grads)
+                self.assertEqual(len(params_grads), 1)
+                self.assertEqual(len(block.ops), count_ops + 5)
+                self.assertEqual(block.ops[-1].name(), 'pd_op.add_n')
+                self.assertEqual(block.ops[-3].name(), 'pd_op.scale')
+                self.assertEqual(block.ops[-5].name(), 'pd_op.sign')
+
 
 def bow_net(
     data,
diff --git a/test/sequence/test_sequence_mask.py b/test/sequence/test_sequence_mask.py
@@ -71,7 +71,7 @@ def calc_ground_truth_mask(self):
         return (index_broadcast < x_broadcast).astype(self.mask_dtype)
 
     def test_check_output(self):
-        self.check_output()
+        self.check_output(check_pir=True)
 
 
 class SequenceMaskTest1(SequenceMaskTestBase):
@@ -139,7 +139,7 @@ def calc_ground_truth_mask(self):
         return (index_broadcast < x_broadcast).astype(self.mask_dtype)
 
     def test_check_output(self):
-        self.check_output()
+        self.check_output(check_pir=True)
 
 
 class SequenceMaskTest1_tensor_attr(SequenceMaskTestBase_tensor_attr):

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,6 @@`
`100`	`100`	`'self_dp_attention',`
`101`	`101`	`'get_tensor_from_selected_rows',`
`102`	`102`	`'print',`
`103`		`- 'sequence_mask',`
`104`	`103`	`'number_count',`
`105`	`104`	`'assign_value',`
`106`	`105`	`]`
Original file line number	Diff line number	Diff line change
`@@ -858,7 +858,7 @@ def uniform(shape, dtype=None, min=-1.0, max=1.0, seed=0, name=None):`
`858`	`858`	`)`
`859`	`859`	`)`
`860`	`860`
`861`		`- if not isinstance(dtype, core.VarDesc.VarType):`
	`861`	`+ if not isinstance(dtype, (core.VarDesc.VarType, core.DataType)):`
`862`	`862`	`dtype = convert_np_dtype_to_dtype_(dtype)`
`863`	`863`
`864`	`864`	`if in_dynamic_mode():`