【Hackathon No.27】为 Paddle 新增 frac 数学计算API (#41226)

python/paddle/__init__.py

@@ -268,6 +268,7 @@
 from .tensor.math import fmin  # noqa: F401
 from .tensor.math import inner  # noqa: F401
 from .tensor.math import outer  # noqa: F401
+from .tensor.math import frac  # noqa: F401
 
 from .tensor.random import bernoulli  # noqa: F401
 from .tensor.random import poisson  # noqa: F401
@@ -606,6 +607,7 @@
            'concat',
            'check_shape',
            'trunc',
+           'frac',
            'digamma',
            'standard_normal',
            'diagonal',

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

@@ -0,0 +1,118 @@
+#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import unittest
+import numpy as np
+import paddle
+import paddle.fluid as fluid
+import paddle.fluid.core as core
+from paddle.fluid import Program, program_guard
+from paddle.fluid.framework import _test_eager_guard
+
+
+def ref_frac(x):
+    return x - np.trunc(x)
+
+
+class TestFracAPI(unittest.TestCase):
+    """Test Frac API"""
+
+    def set_dtype(self):
+        self.dtype = 'float64'
+
+    def setUp(self):
+        self.set_dtype()
+        self.x_np = np.random.uniform(-3, 3, [2, 3]).astype(self.dtype)
+        self.place = paddle.CUDAPlace(0) if core.is_compiled_with_cuda() \
+            else paddle.CPUPlace()
+
+    def test_api_static(self):
+        paddle.enable_static()
+        with program_guard(Program()):
+            input = fluid.data('X', self.x_np.shape, self.x_np.dtype)
+            out = paddle.frac(input)
+            place = fluid.CPUPlace()
+            if fluid.core.is_compiled_with_cuda():
+                place = fluid.CUDAPlace(0)
+            exe = fluid.Executor(place)
+            res = exe.run(feed={'X': self.x_np}, fetch_list=[out])
+        out_ref = ref_frac(self.x_np)
+        self.assertTrue(np.allclose(out_ref, res))
+
+    def test_api_dygraph(self):
+        paddle.disable_static(self.place)
+        x = paddle.to_tensor(self.x_np)
+        out = paddle.frac(x)
+        out_ref = ref_frac(self.x_np)
+        self.assertTrue(np.allclose(out_ref, out.numpy()))
+
+    def test_api_eager(self):
+        paddle.disable_static(self.place)
+        with _test_eager_guard():
+            x_tensor = paddle.to_tensor(self.x_np)
+            out = paddle.frac(x_tensor)
+        out_ref = ref_frac(self.x_np)
+        self.assertTrue(np.allclose(out_ref, out.numpy()))
+        paddle.enable_static()
+
+    def test_api_eager_dygraph(self):
+        with _test_eager_guard():
+            self.test_api_dygraph()
+
+
+class TestFracInt32(TestFracAPI):
+    """Test Frac API with data type int32"""
+
+    def set_dtype(self):
+        self.dtype = 'int32'
+
+
+class TestFracInt64(TestFracAPI):
+    """Test Frac API with data type int64"""
+
+    def set_dtype(self):
+        self.dtype = 'int64'
+
+
+class TestFracFloat32(TestFracAPI):
+    """Test Frac API with data type float32"""
+
+    def set_dtype(self):
+        self.dtype = 'float32'
+
+
+class TestFracError(unittest.TestCase):
+    """Test Frac Error"""
+
+    def setUp(self):
+        self.x_np = np.random.uniform(-3, 3, [2, 3]).astype('int16')
+        self.place = paddle.CUDAPlace(0) if core.is_compiled_with_cuda() \
+            else paddle.CPUPlace()
+
+    def test_static_error(self):
+        paddle.enable_static()
+        with paddle.static.program_guard(paddle.static.Program()):
+            x = paddle.fluid.data('X', [5, 5], 'bool')
+            self.assertRaises(TypeError, paddle.frac, x)
+
+    def test_dygraph_error(self):
+        paddle.disable_static(self.place)
+        x = paddle.to_tensor(self.x_np, dtype='int16')
+        self.assertRaises(TypeError, paddle.frac, x)
+
+
+if __name__ == '__main__':
+    unittest.main()

python/paddle/tensor/__init__.py

@@ -228,6 +228,7 @@
 from .math import fmin  # noqa: F401
 from .math import inner  # noqa: F401
 from .math import outer  # noqa: F401
+from .math import frac  # noqa: F401
 
 from .random import multinomial  # noqa: F401
 from .random import standard_normal  # noqa: F401
@@ -454,6 +455,7 @@
            'digamma',
            'diagonal',
            'trunc',
+           'frac',
            'bitwise_and',
            'bitwise_or',
            'bitwise_xor',

python/paddle/tensor/math.py

@@ -4385,3 +4385,57 @@ def angle(x, name=None):
     outputs = {"Out": out}
     helper.append_op(type=op_type, inputs=inputs, outputs=outputs)
     return out
+
+def frac(x, name=None):
+    """
+    This API is used to return the fractional portion of each element in input.
+
+    Args:
+        x (Tensor): The input tensor, which data type should be int32, int64, float32, float64.
+        name: (str, optional): Name for operation (optional, default is None). For more
+
+    Returns:
+        Tensor: The output Tensor of frac.
+
+    Examples:
+        .. code-block:: Python
+
+            import paddle
+            import numpy as np
+
+            input = paddle.rand([3, 3], 'float32')
+            print(input.numpy())
+            # [[ 1.2203873  -1.0035421  -0.35193074]
+            #  [-0.00928353  0.58917075 -0.8407828 ]
+            #  [-1.5131804   0.5850153  -0.17597814]]
+
+            output = paddle.frac(input)
+            print(output.numpy())
+            # [[ 0.22038734 -0.00354207 -0.35193074]
+            #  [-0.00928353  0.58917075 -0.8407828 ]
+            #  [-0.5131804   0.5850153  -0.17597814]]
+    """
+    op_type = 'elementwise_sub'
+    axis = -1
+    act = None
+    if x.dtype not in [paddle.int32, paddle.int64, paddle.float32, paddle.float64]:
+        raise TypeError(
+            "The data type of input must be one of ['int32', 'int64', 'float32', 'float64'], but got {}".format(x.dtype))
+    if in_dygraph_mode():
+        y = _C_ops.final_state_trunc(x)
+        return _C_ops.final_state_subtract(x, y)
+    else:
+        if _in_legacy_dygraph():
+            y = _C_ops.trunc(x)
+            return _elementwise_op_in_dygraph(
+                x, y, axis=axis, act=act, op_name=op_type)
+        else:
+            inputs = {"X": x}
+            attrs = {}
+
+            helper = LayerHelper("trunc", **locals())
+            check_variable_and_dtype(x, "X", ['int32', 'int64', 'float32', 'float64'], 'trunc')
+            y = helper.create_variable_for_type_inference(dtype=x.dtype)
+            helper.append_op(
+                type="trunc", inputs=inputs, attrs=attrs, outputs={"Out": y})
+            return _elementwise_op(LayerHelper(op_type, **locals()))