ones_like API: remove device, input -> x

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

@@ -0,0 +1,80 @@
+#   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
+from paddle import ones_like
+from paddle.fluid import core, Program, program_guard
+
+
+class TestOnesLikeAPIError(unittest.TestCase):
+    def test_errors(self):
+        with program_guard(Program(), Program()):
+            x = paddle.data('x', [3, 4])
+            self.assertRaises(TypeError, ones_like, x, 'int8')
+
+
+class TestOnesLikeAPI(unittest.TestCase):
+    def test_api(self):
+        shape = [3, 4]
+        startup_program = Program()
+        train_program = Program()
+        with program_guard(train_program, startup_program):
+            x = paddle.data('X', shape)
+
+            # 'bool', 'float32', 'float64', 'int32', 'int64'
+            out1 = ones_like(x)
+            out2 = ones_like(x, np.bool)
+            out3 = ones_like(x, 'float64')
+            out4 = ones_like(x, 'int32')
+            out5 = ones_like(x, 'int64')
+
+        place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda(
+        ) else fluid.CPUPlace()
+        exe = fluid.Executor(place)
+        outs = exe.run(train_program,
+                       feed={'X': np.ones(shape).astype('float32')},
+                       fetch_list=[out1, out2, out3, out4, out5])
+
+        for i, dtype in enumerate(
+            [np.float32, np.bool, np.float64, np.int32, np.int64]):
+            self.assertEqual(outs[i].dtype, dtype)
+            self.assertEqual((outs[i] == np.ones(shape, dtype)).all(), True)
+
+
+class TestOnesLikeImpeartive(unittest.TestCase):
+    def test_out(self):
+        shape = [3, 4]
+        place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda(
+        ) else fluid.CPUPlace()
+        with paddle.imperative.guard(place):
+            x = paddle.imperative.to_variable(np.ones(shape))
+            for dtype in [np.bool, np.float32, np.float64, np.int32, np.int64]:
+                out = ones_like(x, dtype)
+                self.assertEqual((out.numpy() == np.ones(shape, dtype)).all(),
+                                 True)
+
+            out = paddle.tensor.ones_like(x)
+            self.assertEqual((out.numpy() == np.ones(shape, dtype)).all(), True)
+
+            out = paddle.tensor.creation.ones_like(x)
+            self.assertEqual((out.numpy() == np.ones(shape, dtype)).all(), True)
+
+
+if __name__ == "__main__":
+    unittest.main()

python/paddle/tensor/creation.py

@@ -164,74 +164,47 @@ def ones(shape, dtype=None, name=None):
     return fill_constant(value=1.0, shape=shape, dtype=dtype, name=name)
 
 
-def ones_like(input, dtype=None, device=None, name=None):
+def ones_like(x, dtype=None, name=None):
     """
 	:alias_main: paddle.ones_like
-	:alias: paddle.ones_like,paddle.tensor.ones_like,paddle.tensor.creation.ones_like
+	:alias: paddle.tensor.ones_like, paddle.tensor.creation.ones_like
 
-    This function creates a ones tensor which has identical shape and dtype 
-    with `input`.
+    This OP returns a Tensor filled with the value 0, with the same shape and
+    data type (use ``dtype`` if ``dtype`` is not None) as ``x``.
 
     Args:
-        input(Variable): The input tensor which specifies shape and dtype.The dtype of input can be 
-            float32, float64, int32, int64.
-        dtype(np.dtype|core.VarDesc.VarType|str, optional): The data type can be set bool, float32, float64, int32, int64. 
-            The default value is None, the dtype is the same as input.
-        device(str, optional): Which device to run the operator. The :attr:`device` must be
-            None, 'cpu', 'gpu'. If :attr:`device` is None, it will be choose the device that the user set in 
-            the paddle program. Default value is None.
-        name(str, optional): The name of output variable, normally there is no need for user to set this this property. 
-            Default value is None, the framework set the name of output variable.  
+        x(Tensor): The input tensor which specifies shape and dtype. The
+            dtype of ``x`` can be bool, float16, float32, float64, int32, int64.
+        dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the
+            output tensor. Supported data types: bool, float16, float32, float64,
+            int32, int64. If ``dtype`` is None, the data type is the same as ``x``.
+            Default is None.
+        name(str, optional): The default value is None. Normally there is no
+            need for user to set this property. For more information, please
+            refer to :ref:`api_guide_Name`.
+
     Returns:
-        out(Variable): The tensor variable storing the output.
+        Tensor: A Tensor filled with the value 1, with the same shape and
+        data type (use ``dtype`` if ``dtype`` is not None) as ``x``.
+
+    Raise:
+        TypeError: If ``dtype`` is not None and is not bool, float16, float32,
+            float64, int32 or int64.
 
     Examples:
         .. code-block:: python
 
-          import paddle
-          import paddle.fluid as fluid
+        import paddle
+        import numpy as np
 
-          x = fluid.data(name='x', dtype='float32', shape=[3])
-          data = paddle.ones_like(x) # data=[1.0, 1.0, 1.0]
-          data1 = paddle.ones_like(input=x, device="gpu") data1=[1.0, 1.0. 1.0]
+        paddle.enable_imperative()
 
-    """
+        x = paddle.imperative.to_variable(np.array([1,2,3], dtype='float32'))
+        out1 = paddle.zeros_like(x) # [1., 1., 1.]
+        out2 = paddle.zeros_like(x, dtype='int32') # [1, 1, 1]
 
-    helper = LayerHelper("zeros_like", **locals())
-
-    attrs = {"value": 1.0}
-    var_dtype = None
-    if dtype is not None:
-        check_dtype(
-            dtype, 'create data type',
-            ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
-            'zeros_like')
-        var_dtype = convert_np_dtype_to_dtype_(dtype)
-        attrs["dtype"] = var_dtype
-    else:
-        var_dtype = input.dtype
-
-    out = helper.create_variable_for_type_inference(dtype=var_dtype)
-
-    if device is not None:
-        if device not in ['cpu', 'gpu']:
-            raise ValueError(
-                "The value of 'device' in zeros_op must be cpu or gpu, but received %s."
-                % (device))
-        with fluid.device_guard(device):
-            helper.append_op(
-                type='fill_any_like',
-                inputs={'X': [input]},
-                attrs=attrs,
-                outputs={'Out': [out]})
-            return out
-    helper.append_op(
-        type='fill_any_like',
-        inputs={'X': [input]},
-        attrs=attrs,
-        outputs={'Out': [out]})
-    out.stop_gradient = True
-    return out
+    """
+    return full_like(x=x, fill_value=1, dtype=dtype, name=name)
 
 
 def zeros(shape, dtype=None, name=None):