diff --git a/python/paddle/__init__.py b/python/paddle/__init__.py index 227cf967642c1..63f16c4eb78f1 100755 --- a/python/paddle/__init__.py +++ b/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', diff --git a/python/paddle/fluid/tests/unittests/test_frac_api.py b/python/paddle/fluid/tests/unittests/test_frac_api.py new file mode 100644 index 0000000000000..4ee3096cde78f --- /dev/null +++ b/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() diff --git a/python/paddle/tensor/__init__.py b/python/paddle/tensor/__init__.py index fc6c8f106ce4f..3c4647d4d6b68 100755 --- a/python/paddle/tensor/__init__.py +++ b/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', diff --git a/python/paddle/tensor/math.py b/python/paddle/tensor/math.py index 3a2d08af88ff8..cfc9abb86984d 100644 --- a/python/paddle/tensor/math.py +++ b/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()))