Move api(lgamma) from legacy_api.yaml to api.yaml

paddle/phi/api/yaml/api.yaml

@@ -98,6 +98,15 @@
     func : erf
   backward : erf_grad
 
+- api : lgamma
+  args : (Tensor x)
+  output : Tensor(out)
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : lgamma
+  backward : lgamma_grad 
+
 - api : mv
   args : (Tensor x, Tensor vec)
   output : Tensor

paddle/phi/api/yaml/api_compat.yaml

@@ -77,6 +77,12 @@
   outputs :
     out : Out
 
+- api : lgamma
+  inputs :
+    x : X
+  outputs :
+    out : Out
+
 - api : mv
   inputs :
     {x : X, vec : Vec}

paddle/phi/api/yaml/backward.yaml

@@ -105,6 +105,16 @@
     func : erf_grad
     data_type : out_grad
 
+- backward_api : lgamma_grad
+  forward : lgamma(Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param: [x]
+  kernel :
+    func : lgamma_grad
+
 - backward_api : mv_grad
   forward : mv (Tensor x, Tensor vec) -> Tensor(out)
   args : (Tensor x, Tensor vec, Tensor out_grad)

paddle/phi/api/yaml/legacy_api.yaml

@@ -1263,15 +1263,6 @@
   kernel :
     func : less_than
 
-- api : lgamma
-  args : (Tensor x)
-  output : Tensor(out)
-  infer_meta :
-    func : UnchangedInferMeta
-  kernel :
-    func : lgamma
-  backward : lgamma_grad
-
 - api : linspace
   args : (Tensor start, Tensor stop, Tensor number, DataType dtype)
   output : Tensor

paddle/phi/api/yaml/legacy_backward.yaml

@@ -1106,16 +1106,6 @@
   kernel :
     func : lerp_grad
 
-- backward_api : lgamma_grad
-  forward : lgamma(Tensor x) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param: [x]
-  kernel :
-    func : lgamma_grad
-
 - backward_api : log10_grad
   forward : log10 (Tensor x) -> Tensor(out)
   args : (Tensor x, Tensor out_grad)

python/paddle/fluid/layers/ops.py

@@ -20,6 +20,7 @@
 from ..data_feeder import convert_dtype, check_variable_and_dtype, check_type, check_dtype
 from paddle.utils import deprecated
 from paddle import _C_ops
+import paddle
 
 __deprecated_func_name__ = {
     'tanh_shrink': 'tanhshrink',
@@ -37,28 +38,9 @@
 ]
 
 __unary_func__ = [
-    'exp',
-    'expm1',
-    'atan',
-    'sqrt',
-    'rsqrt',
-    'abs',
-    'ceil',
-    'floor',
-    'cos',
-    'tan',
-    'acos',
-    'sin',
-    'sinh',
-    'asin',
-    'cosh',
-    'round',
-    'reciprocal',
-    'square',
-    'lgamma',
-    'acosh',
-    'asinh',
-    'atanh',
+    'exp', 'expm1', 'atan', 'sqrt', 'rsqrt', 'abs', 'ceil', 'floor', 'cos',
+    'tan', 'acos', 'sin', 'sinh', 'asin', 'cosh', 'round', 'reciprocal',
+    'square', 'acosh', 'asinh', 'atanh', 'lgamma'
 ]
 
 __inplace_unary_func__ = [
@@ -480,20 +462,6 @@
 
 """)
 
-add_sample_code(
-    globals()["lgamma"], r"""
-Examples:
-    .. code-block:: python
-
-        import paddle
-
-        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
-        out = paddle.lgamma(x)
-        print(out)
-        # [1.31452441, 1.76149750, 2.25271273, 1.09579802]
-
-""")
-
 add_sample_code(
     globals()["softplus"], r"""
 Examples:
@@ -860,3 +828,31 @@ def erf(x, name=None):
         print(out)
         # [-0.42839236 -0.22270259  0.11246292  0.32862676]
 """
+
+
+def lgamma(x, name=None):
+    r"""
+    Calculates the lgamma of the given input tensor, element-wise.
+
+    This operator performs elementwise lgamma for input $X$.
+    :math:`out = log\Gamma(x)`
+
+
+    Args:
+        x (Tensor): Input Tensor. Must be one of the following types: float32, float64.
+        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+    Returns:
+        Tensor, the lgamma of the input Tensor, the shape and data type is the same with input.
+
+    Examples:
+        .. code-block:: python
+
+            import paddle
+
+            x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+            out = paddle.lgamma(x)
+            print(out)
+            # [1.31452441, 1.76149750, 2.25271273, 1.09579802]
+    """
+    return paddle.Tensor.lgamma(x)

python/paddle/fluid/tests/unittests/test_lgamma_op.py

@@ -17,6 +17,7 @@
 import numpy as np
 import paddle
 from op_test import OpTest
+from scipy import special
 
 paddle.enable_static()
 
@@ -58,5 +59,19 @@ def test_check_grad_normal(self):
                         check_eager=True)
 
 
+class TestLgammaOpApi(unittest.TestCase):
+
+    def test_lgamma(self):
+        paddle.disable_static()
+        self.dtype = "float32"
+        shape = (1, 4)
+        data = np.random.random(shape).astype(self.dtype) + 1
+        data_ = paddle.to_tensor(data)
+        out = paddle.fluid.layers.lgamma(data_)
+        result = special.gammaln(data)
+        self.assertTrue(np.allclose(result, out.numpy()))
+        paddle.enable_static()
+
+
 if __name__ == "__main__":
     unittest.main()

python/paddle/tensor/math.py

@@ -63,7 +63,6 @@
 from .ops import sqrt    # noqa: F401
 from .ops import sqrt_    # noqa: F401
 from .ops import sin    # noqa: F401
-from .ops import lgamma    # noqa: F401
 from .ops import asinh    # noqa: F401
 from .ops import acosh    # noqa: F401
 from .ops import atanh    # noqa: F401
@@ -3713,6 +3712,43 @@ def digamma(x, name=None):
     helper.append_op(type='digamma', inputs={'X': x}, outputs={'Out': out})
     return out
 
+def lgamma(x, name=None):
+    r"""
+    Calculates the lgamma of the given input tensor, element-wise.
+
+    This operator performs elementwise lgamma for input $X$.
+    :math:`out = log\Gamma(x)`
+
+
+    Args:
+        x (Tensor): Input Tensor. Must be one of the following types: float32, float64.
+        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+    Returns:
+        Tensor, the lgamma of the input Tensor, the shape and data type is the same with input.
+
+    Examples:
+        .. code-block:: python
+
+            import paddle
+
+            x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+            out = paddle.lgamma(x)
+            print(out)
+            # [1.31452441, 1.76149750, 2.25271273, 1.09579802]
+    """
+    if in_dygraph_mode():
+        return _C_ops.final_state_lgamma(x)
+    elif _in_legacy_dygraph():
+        return _C_ops.lgamma(x)
+
+    check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'lgamma')
+    helper = LayerHelper('lgamma', **locals())
+    out = helper.create_variable_for_type_inference(x.dtype)
+    helper.append_op(type='lgamma', inputs={'X': x}, outputs={'Out': out})
+    return out
+
+
 def neg(x, name=None):
     """
     This function computes the negative of the Tensor elementwisely.