tensor.py 61.3 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
D
dzhwinter 已提交
2
#
D
dzhwinter 已提交
3 4 5
# 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
D
dzhwinter 已提交
6
#
D
dzhwinter 已提交
7
#     http://www.apache.org/licenses/LICENSE-2.0
D
dzhwinter 已提交
8
#
Y
yuyang18 已提交
9
# Unlessf required by applicable law or agreed to in writing, software
D
dzhwinter 已提交
10 11 12 13 14
# 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.

15
from __future__ import print_function
16
import six
17
from six.moves import reduce
Y
Yu Yang 已提交
18
from ..layer_helper import LayerHelper
19
from ..param_attr import ParamAttr
20
from ..initializer import Initializer
21
from ..framework import convert_np_dtype_to_dtype_, in_dygraph_mode, _varbase_creator
X
xuwei06 已提交
22
from ..framework import Variable
23
from ..initializer import Constant
24
from ..core import VarDesc
25
from .. import core
26
from .layer_function_generator import templatedoc
L
Leo Chen 已提交
27
from . import utils
28
from ..data_feeder import check_variable_and_dtype, check_type, check_dtype, convert_dtype
X
xuwei06 已提交
29
import numpy
30
import warnings
Y
Yu Yang 已提交
31 32

__all__ = [
L
li099 已提交
33 34 35
    'create_tensor', 'create_parameter', 'create_global_var', 'cast',
    'tensor_array_to_tensor', 'concat', 'sums', 'assign',
    'fill_constant_batch_size_like', 'fill_constant', 'argmin', 'argmax',
Z
zhoukunsheng 已提交
36
    'argsort', 'ones', 'zeros', 'reverse', 'has_inf', 'has_nan', 'isfinite',
37
    'range', 'linspace', 'zeros_like', 'ones_like', 'diag', 'eye'
Y
Yu Yang 已提交
38 39 40
]


X
xuwei06 已提交
41
def create_tensor(dtype, name=None, persistable=False):
42
    """
W
wangchaochaohu 已提交
43
    Create a variable, which will hold a Tensor with data type dtype.
44 45

    Args:
W
wangchaochaohu 已提交
46 47 48 49
        dtype(string|numpy.dtype): the data type of Tensor to be created, the
            data type is bool, float16, float32, float64, int8, int16, int32 and int64.
        name(string, 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`
Q
update  
qiaolongfei 已提交
50
        persistable(bool): Set the persistable flag of the create tensor.
W
wangchaochaohu 已提交
51
            default value is False.
52 53

    Returns:
W
wangchaochaohu 已提交
54
        Variable: The tensor to be created according to dtype.
55 56 57 58

    Examples:
        .. code-block:: python

59
          import paddle.fluid as fluid
60 61
          tensor = fluid.layers.create_tensor(dtype='float32')
    """
62 63 64 65
    check_dtype(dtype, 'dtype', [
        'bool', 'float16', 'float32', 'float64', 'int8', 'int32', 'int32',
        'int64'
    ], 'create_tensor')
Y
Yu Yang 已提交
66
    helper = LayerHelper("create_tensor", **locals())
X
xuwei06 已提交
67 68
    return helper.create_variable(
        name=helper.name, dtype=dtype, persistable=persistable)
Y
Yu Yang 已提交
69 70


71 72
def create_parameter(shape,
                     dtype,
X
xuwei06 已提交
73
                     name=None,
74 75 76 77
                     attr=None,
                     is_bias=False,
                     default_initializer=None):
    """
78
	:api_attr: Static Graph
S
swtkiwi 已提交
79

80
    This function creates a parameter. The parameter is a learnable variable, which can have
Y
yuyang18 已提交
81 82 83 84 85
    gradient, and can be optimized.

    NOTE: this is a very low-level API. This API is useful when you create
    operator by your self. instead of using layers.

86 87 88 89 90 91 92
    Parameters:
        shape (list of int): Shape of the parameter
        dtype (str): Data type of the parameter
        name (str, optional): For detailed information, please refer to
           :ref:`api_guide_Name` . Usually name is no need to set and None by default.
        attr (ParamAttr, optional): Attributes of the parameter
        is_bias (bool, optional): This can affect which default initializer is chosen
93 94 95
                       when default_initializer is None. If is_bias,
                       initializer.Constant(0.0) will be used. Otherwise,
                       Xavier() will be used.
96
        default_initializer (Initializer, optional): Initializer for the parameter
97 98

    Returns:
99
        The created parameter.
Y
yuyang18 已提交
100 101

    Examples:
102 103
        .. code-block:: python

104
            import paddle.fluid as fluid
105 106
            import paddle.fluid.layers as layers
            W = layers.create_parameter(shape=[784, 200], dtype='float32')
107
    """
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
    check_type(shape, 'shape', (list, tuple, numpy.ndarray), 'create_parameter')
    for item in shape:
        if six.PY2:
            check_type(item, 'item of shape',
                       (int, long, numpy.uint8, numpy.int8, numpy.int16,
                        numpy.int32, numpy.int64), 'create_parameter')
        else:
            check_type(item, 'item of shape',
                       (int, numpy.uint8, numpy.int8, numpy.int16, numpy.int32,
                        numpy.int64), 'create_parameter')

    check_dtype(dtype, 'dtype', [
        'bool', 'float16', 'float32', 'float64', 'int8', 'int16', 'int32',
        'int64', 'uint8'
    ], 'create_parameter')
    check_type(attr, 'attr', (type(None), ParamAttr), 'create_parameter')
    check_type(default_initializer, 'default_initializer',
               (type(None), Initializer), 'create_parameter')

Q
Qiao Longfei 已提交
127
    helper = LayerHelper("create_parameter", **locals())
128
    if attr is None:
X
xuwei06 已提交
129
        attr = ParamAttr(name=name)
130 131
    return helper.create_parameter(attr, shape,
                                   convert_dtype(dtype), is_bias,
132 133 134
                                   default_initializer)


135 136 137 138 139 140 141
def create_global_var(shape,
                      value,
                      dtype,
                      persistable=False,
                      force_cpu=False,
                      name=None):
    """
142
    This function creates a new tensor variable with value in the global block(block 0).
F
fengjiayi 已提交
143

144 145 146
    Parameters:
        shape (list of int): Shape of the variable
        value (float): The value of the variable. The new created
F
fengjiayi 已提交
147
                      variable will be filled with it.
148 149
        dtype (str): Data type of the variable
        persistable (bool, optional): If this variable is persistable.
F
fengjiayi 已提交
150
                           Default: False
151
        force_cpu (bool, optional): Force this variable to be on CPU.
F
fengjiayi 已提交
152
                         Default: False
153 154
        name (str, optional): For detailed information, please refer to
           :ref:`api_guide_Name` . Usually name is no need to set and None by default.
155 156

    Returns:
157
        Variable: The created Variable
F
fengjiayi 已提交
158 159 160 161

    Examples:
        .. code-block:: python

162
            import paddle.fluid as fluid
163 164
            import paddle.fluid.layers as layers
            var = layers.create_global_var(shape=[2,3], value=1.0, dtype='float32',
165
                                           persistable=True, force_cpu=True, name='new_var')
166
    """
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
    check_type(shape, 'shape', (list, tuple, numpy.ndarray),
               'create_global_var')
    for item in shape:
        if six.PY2:
            check_type(item, 'item of shape',
                       (int, long, numpy.uint8, numpy.int8, numpy.int16,
                        numpy.int32, numpy.int64), 'create_global_var')
        else:
            check_type(item, 'item of shape',
                       (int, numpy.uint8, numpy.int8, numpy.int16, numpy.int32,
                        numpy.int64), 'create_global_var')

    check_dtype(dtype, 'dtype', [
        'bool', 'float16', 'float32', 'float64', 'int8', 'int16', 'int32',
        'int64', 'uint8'
    ], 'create_global_var')

Q
Qiao Longfei 已提交
184 185
    helper = LayerHelper("global_var", **locals())
    var = helper.create_global_variable(
M
minqiyang 已提交
186 187 188 189 190
        dtype=dtype,
        shape=shape,
        persistable=persistable,
        name=name,
        stop_gradient=True)
M
minqiyang 已提交
191 192 193
    helper.set_variable_initializer(
        var, initializer=Constant(
            value=float(value), force_cpu=force_cpu))
M
minqiyang 已提交
194

Q
Qiao Longfei 已提交
195 196 197
    return var


198
def cast(x, dtype):
Y
Yu Yang 已提交
199
    """
200 201 202
	:alias_main: paddle.cast
	:alias: paddle.cast,paddle.tensor.cast,paddle.tensor.manipulation.cast
	:old_api: paddle.fluid.layers.cast
S
swtkiwi 已提交
203

204 205 206
    This OP takes in the Variable :attr:`x` with :attr:`x.dtype` and casts it
    to the output with :attr:`dtype`. It's meaningless if the output dtype
    equals the input dtype, but it's fine if you do so.
Y
Yibing Liu 已提交
207 208

    Args:
209 210 211
        x(Variable): An input N-D Tensor with data type bool, float16,
            float32, float64, int32, int64, uint8.
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output:
212
            bool, float16, float32, float64, int8, int32, int64, uint8.
Y
Yibing Liu 已提交
213 214

    Returns:
215
        Variable: A Tensor with the same shape as input's.
Y
Yibing Liu 已提交
216 217 218

    Examples:
        .. code-block:: python
F
fengjiayi 已提交
219

220
            import paddle.fluid as fluid
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
            import numpy as np

            place = fluid.core.CPUPlace()

            x_lod = fluid.data(name="x", shape=[2,2], lod_level=0)
            cast_res1 = fluid.layers.cast(x=x_lod, dtype="uint8")
            cast_res2 = fluid.layers.cast(x=x_lod, dtype=np.int32)

            exe = fluid.Executor(place)
            exe.run(fluid.default_startup_program())

            x_i_lod = fluid.core.LoDTensor()
            x_i_lod.set(np.array([[1.3,-2.4],[0,4]]).astype("float32"), place)
            x_i_lod.set_recursive_sequence_lengths([[0,2]])
            res1 = exe.run(fluid.default_main_program(), feed={'x':x_i_lod}, fetch_list=[cast_res1], return_numpy=False)
            res2 = exe.run(fluid.default_main_program(), feed={'x':x_i_lod}, fetch_list=[cast_res2], return_numpy=False)
            print(np.array(res1[0]), np.array(res1[0]).dtype)
            # [[  1 254]
            #  [  0   4]] uint8
            print(np.array(res2[0]), np.array(res2[0]).dtype)
            # [[ 1 -2]
            #  [ 0  4]] int32
Y
Yu Yang 已提交
243
    """
244 245
    check_variable_and_dtype(
        x, 'x',
246 247
        ['bool', 'float16', 'float32', 'float64', 'int32', 'int64', 'uint8'],
        'cast')
248 249 250 251 252 253
    check_dtype(dtype, 'dtype', [
        'bool', 'float16', 'float32', 'float64', 'int8', 'int32', 'int64',
        'uint8'
    ], 'cast')

    helper = LayerHelper('cast', **locals())
X
Xin Pan 已提交
254
    out = helper.create_variable_for_type_inference(dtype=dtype)
Y
Yu Yang 已提交
255 256 257 258 259 260 261 262 263
    helper.append_op(
        type='cast',
        inputs={'X': [x]},
        outputs={'Out': [out]},
        attrs={'in_dtype': x.dtype,
               'out_dtype': out.dtype})
    return out


264
def concat(input, axis=0, name=None):
Y
Yu Yang 已提交
265
    """
266 267 268
	:alias_main: paddle.concat
	:alias: paddle.concat,paddle.tensor.concat,paddle.tensor.manipulation.concat
	:old_api: paddle.fluid.layers.concat
S
swtkiwi 已提交
269

270 271
    **Concat**

272
    This OP concatenates the input along the axis.
273 274

    Args:
275 276
        input(list): List of input Tensors with data type float32, float64, int32,
            int64.
277
        axis(int32|Variable, optional):  A scalar with type ``int32`` or a ``Tensor`` with shape [1] and type ``int32``. Axis to compute indices along. The effective range
278 279 280 281 282
            is [-R, R), where R is Rank(x). when axis<0, it works the same way
            as axis+R. Default is 0.
        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`.
283 284

    Returns:
285
        Variable: A Tensor with the same data type as input's.
286 287 288

    Examples:
        .. code-block:: python
F
fengjiayi 已提交
289

290
            import paddle.fluid as fluid
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
            import numpy as np

            in1 = np.array([[1,2,3],
                            [4,5,6]])
            in2 = np.array([[11,12,13],
                            [14,15,16]])
            in3 = np.array([[21,22],
                            [23,24]])
            with fluid.dygraph.guard():
                x1 = fluid.dygraph.to_variable(in1)
                x2 = fluid.dygraph.to_variable(in2)
                x3 = fluid.dygraph.to_variable(in3)
                out1 = fluid.layers.concat(input=[x1,x2,x3], axis=-1)
                out2 = fluid.layers.concat(input=[x1,x2], axis=0)
                print(out1.numpy())
                # [[ 1  2  3 11 12 13 21 22]
                #  [ 4  5  6 14 15 16 23 24]]
                print(out2.numpy())
                # [[ 1  2  3]
                #  [ 4  5  6]
                #  [11 12 13]
                #  [14 15 16]]
Y
Yu Yang 已提交
313
    """
314 315

    if in_dygraph_mode():
S
songyouwei 已提交
316 317 318 319 320
        if isinstance(axis, Variable):
            axis = axis.numpy()
            assert axis.shape == (
                1, ), "axis of type Variable should have shape [1]"
            axis = axis[0]
321
        return core.ops.concat(input, 'axis', axis)
322

323 324 325 326 327
    if not isinstance(input, list):
        warnings.warn(
            "The type of input in concat should be list, but received %s." %
            (type(input)))
        input = [input]
328
    for id, x in enumerate(input):
329 330
        check_variable_and_dtype(
            x, 'input[' + str(id) + ']',
331 332
            ['float16', 'float32', 'float64', 'int32', 'int64'], 'concat')
    check_type(axis, 'axis', (int, Variable), 'concat')
333

334
    helper = LayerHelper('concat', **locals())
X
Xin Pan 已提交
335
    out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358

    if input[0].desc.type() == core.VarDesc.VarType.LOD_TENSOR_ARRAY:
        assert len(input) == 1, "If the elements of 'input' in concat are Variable(LoDTensorArray), " \
                            "number of the elements must be 1, but received %s." % len(x)
        out_index = helper.create_variable_for_type_inference(dtype="int32")
        helper.append_op(
            type='tensor_array_to_tensor',
            inputs={'X': input[0]},
            outputs={'Out': [out],
                     'OutIndex': [out_index]},
            attrs={'axis': axis,
                   'use_stack': False})
    else:
        inputs = {'X': input}
        attrs = {}
        if isinstance(axis, Variable):
            axis.stop_gradient = True
            inputs['AxisTensor'] = axis
        else:
            attrs['axis'] = axis

        helper.append_op(
            type='concat', inputs=inputs, outputs={'Out': [out]}, attrs=attrs)
Y
Yu Yang 已提交
359 360 361
    return out


G
Guo Sheng 已提交
362
def tensor_array_to_tensor(input, axis=1, name=None, use_stack=False):
L
li099 已提交
363
    """
G
Guo Sheng 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
    This function concatenates or stacks all tensors in the input LoDTensorArray
    along the axis mentioned and returns that as the output.

    For Example:

    .. code-block:: text

        Case 1:

            Given:

                input.data = {[[0.6, 0.1, 0.3],
                               [0.5, 0.3, 0.2]],
                              [[1.3],
                               [1.8]],
                              [[2.3, 2.1],
                               [2.5, 2.4]]}

                axis = 1, use_stack = False

            Then:

                output.data = [[0.6, 0.1, 0.3, 1.3, 2.3, 2.1],
                               [0.5, 0.3, 0.2, 1.8, 2.5, 2.4]]

                output_index.data = [3, 1, 2]

        Case 2:

            Given:

                input.data = {[[0.6, 0.1],
                               [0.5, 0.3]],
                              [[0.3, 1.3],
                               [0.2, 1.8]],
                              [[2.3, 2.1],
                               [2.5, 2.4]]}

                axis = 1, use_stack = True

            Then:

                output.data = [[[0.6, 0.1]
                                [0.3, 1.3]
                                [2.3, 2.1],
                               [[0.5, 0.3]
                                [0.2, 1.8]
                                [2.5, 2.4]]]

                output_index.data = [2, 2, 2]
L
li099 已提交
414 415

    Args:
G
Guo Sheng 已提交
416 417 418 419 420 421 422
        input(Variable): A LodTensorArray variable.
        axis(int): The axis along which the tensors in attr::`input` will be
            concatenated or stacked.
        name(str|None): A name for this layer(optional). If set None, the layer
                       will be named automatically.
        use_stack(bool): Act as concat_op or stack_op. For stack mode, all
            tensors in the tensor array must have the same shape.
L
li099 已提交
423 424

    Returns:
G
Guo Sheng 已提交
425 426 427
        Variable: The concatenated or stacked tensor variable.
        Variable: A 1-D tensor variable with int32 data type. The data in this \
            tensor contains all input including tensors' sizes along the axis.
L
li099 已提交
428 429 430 431

    Examples:
        .. code-block:: python

432
            import paddle.fluid as fluid
433
            import numpy as np
G
Guo Sheng 已提交
434 435 436 437 438 439 440
            x0 = fluid.layers.assign(np.random.rand(2, 2).astype("float32"))
            x1 = fluid.layers.assign(np.random.rand(2, 2).astype("float32"))
            i = fluid.layers.fill_constant(shape=[1], dtype="int64", value=0)
            array = fluid.layers.create_array(dtype='float32')
            fluid.layers.array_write(x0, i, array)
            fluid.layers.array_write(x1, i + 1, array)
            output, output_index = fluid.layers.tensor_array_to_tensor(input=array)
L
li099 已提交
441
    """
442 443 444 445 446 447 448 449 450 451 452
    if in_dygraph_mode():
        assert isinstance(
            input, list), "The 'input' in tensor_array_to_tensor must be list"
        from .nn import stack, concat
        from ..dygraph import to_variable
        op = stack if use_stack else concat
        res = op(input, axis=axis)
        sizes = to_variable(
            numpy.array(list(map(lambda x: int(x.shape[axis]), input))))
        return res, sizes

453 454 455 456 457
    check_type(input, 'input', (list, Variable), 'tensor_array_to_tensor')
    if isinstance(input, list):
        for i, input_x in enumerate(input):
            check_type(input_x, 'input[' + str(i) + ']', Variable,
                       'tensor_array_to_tensor')
L
li099 已提交
458
    helper = LayerHelper('tensor_array_to_tensor', **locals())
L
li099 已提交
459 460 461
    out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
    out_index = helper.create_variable_for_type_inference(dtype="int32")
    helper.append_op(
L
li099 已提交
462
        type='tensor_array_to_tensor',
L
li099 已提交
463 464 465
        inputs={'X': input},
        outputs={'Out': [out],
                 'OutIndex': [out_index]},
G
Guo Sheng 已提交
466 467
        attrs={'axis': axis,
               'use_stack': use_stack})
L
li099 已提交
468 469 470
    return out, out_index


471
def sums(input, out=None):
F
fengjiayi 已提交
472
    """
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
    This function computes the sum of multiple input Tensors elementwisely.

    - Case 1, sum of 3 Tensors

    .. code-block:: text

        # Input Tensors
        x0.shape = [2, 3]
        x0.data = [[1., 2., 3.],
                   [4., 5., 6.]]
        x1.shape = [2, 3]
        x1.data = [[10., 20., 30.],
                   [40., 50., 60.]]
        x2.shape = [2, 3]
        x2.data = [[100., 200., 300.],
                   [400., 500., 600.]]

        # Output Tensor
        out.shape = [2, 3]
        out.data = [[111., 222., 333.],
                    [444., 555., 666.]]
K
kavyasrinet 已提交
494 495

    Args:
496 497 498 499
        input (list): A list of Variables which hold input Tensors with the same
            data type and shape. Optional data types are: float32, float64, int32, int64.
        out (Variable, optional): Output Tensor. It can be any existing Variable.
            The default value is None, then a new Variable will be created and returned.
K
kavyasrinet 已提交
500 501

    Returns:
502 503
        Variable: The sum of inputs. The shape and data type is the same with input. \
            If :code:`out` is not None, the returned value is :code:`out` .
K
kavyasrinet 已提交
504 505

    Examples:
F
fengjiayi 已提交
506
        .. code-block:: python
K
kavyasrinet 已提交
507

508 509 510 511 512 513 514 515 516
            import paddle.fluid as fluid

            x0 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=1)
            x1 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=2)
            x2 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=3)
            x3 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=0)

            # Sum of multiple Tensors, the result is stored to a new Variable sum0 (sum0=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]])
            sum0 = fluid.layers.sums(input=[x0, x1, x2])
517

518 519
            # Sum of multiple Tensors, sum1 and x3 represents the same Variable (x3=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]])
            sum1 = fluid.layers.sums(input=[x0, x1, x2], out=x3)
Y
Yu Yang 已提交
520
    """
521 522 523 524 525 526 527 528 529
    check_type(input, 'input', (Variable, tuple, list), 'sums')
    if isinstance(input, list) or isinstance(input, tuple):
        for input_section in input:
            check_variable_and_dtype(input_section, "input", \
                    ['float32', 'float64', 'int32', 'int64'], 'sums')
    else:
        check_variable_and_dtype(input, "input", \
                ['float32', 'float64', 'int32', 'int64'], 'sums')

Y
Yu Yang 已提交
530 531
    helper = LayerHelper('sum', **locals())
    if out is None:
X
Xin Pan 已提交
532 533
        out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())
534 535 536 537
    else:
        check_variable_and_dtype(
            out, "out", ['float32', 'float64', 'int32', 'int64'], 'sums')

T
tensor-tang 已提交
538 539 540 541 542
    helper.append_op(
        type='sum',
        inputs={'X': input},
        outputs={'Out': out},
        attrs={'use_mkldnn': False})
Y
Yu Yang 已提交
543 544 545
    return out


F
fengjiayi 已提交
546
def assign(input, output=None):
547
    """
548 549 550
	:alias_main: paddle.nn.functional.assign
	:alias: paddle.nn.functional.assign,paddle.nn.functional.common.assign
	:old_api: paddle.fluid.layers.assign
S
swtkiwi 已提交
551

552
    The OP copies the :attr:`input` to the :attr:`output`.
553

554 555
    Parameters:
        input (Variable|numpy.ndarray): A tensor or numpy ndarray, its data type supports
556
            float16, float32, float64, int32 and int64.
557 558
        output (Variable, optional): A tensor. If :attr:`output` is None, a new tensor will
            be created as :attr:`output`. Default: None.
559 560

    Returns:
561
        Variable: A tensor with the same shape, data type and value as :attr:`input`.
562 563 564

    Examples:
        .. code-block:: python
565

566
          import paddle.fluid as fluid
567 568 569 570 571 572
          import numpy as np
          data = fluid.layers.fill_constant(shape=[3, 2], value=2.5, dtype='float64') # [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
          result1 = fluid.layers.create_tensor(dtype='float64')
          fluid.layers.assign(data, result1) # result1 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
          result2 = fluid.layers.assign(data)  # result2 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
          result3 = fluid.layers.assign(np.array([[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]], dtype='float32')) # result3 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
573
    """
Y
Yu Yang 已提交
574
    helper = LayerHelper('assign', **locals())
575
    check_type(input, 'input', (Variable, numpy.ndarray), 'assign')
X
xuwei06 已提交
576
    if isinstance(input, Variable):
577 578 579 580
        check_dtype(
            input.dtype, 'input',
            ['float16', 'float32', 'float64', 'int32', 'int64', 'bool'],
            'assign', '(When the type of input in assign is Variable.)')
581 582 583
        if output is None:
            output = helper.create_variable_for_type_inference(
                dtype=input.dtype)
X
xuwei06 已提交
584
        helper.append_op(
R
robot 已提交
585
            type='assign', inputs={'X': [input]}, outputs={'Out': [output]})
X
xuwei06 已提交
586 587
    elif isinstance(input, numpy.ndarray):
        dtype = convert_np_dtype_to_dtype_(input.dtype)
588 589 590 591
        if dtype == VarDesc.VarType.BOOL:
            value_name = "bool_values"
            values = [bool(v) for v in input.flat]
        elif dtype == VarDesc.VarType.FP32:
X
xuwei06 已提交
592
            value_name = "fp32_values"
593
            values = [float(v) for v in input.flat]
594
        elif dtype == VarDesc.VarType.INT32:
X
xuwei06 已提交
595
            value_name = "int32_values"
596
            values = [int(v) for v in input.flat]
597 598 599
        elif dtype == VarDesc.VarType.INT64:
            value_name = "int64_values"
            values = [int(v) for v in input.flat]
X
xuwei06 已提交
600
        else:
601 602
            raise TypeError(
                "When the type of 'input' in assign is numpy.ndarray, "
603
                "the data type of 'input' must be bool, float32, int32 or int64, but "
604
                "received %s." % convert_dtype(dtype))
605 606 607
        if input.size > 1024 * 1024:
            raise ValueError("The size of input is too big. Please consider "
                             "saving it to file and 'load_op' to load it")
608 609 610
        if output is None:
            output = helper.create_variable_for_type_inference(
                dtype=input.dtype)
X
xuwei06 已提交
611 612 613 614 615 616
        helper.append_op(
            type='assign_value',
            outputs={'Out': [output]},
            attrs={
                'dtype': dtype,
                'shape': list(input.shape),
617
                value_name: values
X
xuwei06 已提交
618 619
            })

Y
Yu Yang 已提交
620 621 622
    return output


623
def fill_constant(shape, dtype, value, force_cpu=False, out=None, name=None):
Y
Yu Yang 已提交
624
    """
625 626 627
	:alias_main: paddle.fill_constant
	:alias: paddle.fill_constant,paddle.tensor.fill_constant,paddle.tensor.creation.fill_constant
	:old_api: paddle.fluid.layers.fill_constant
S
swtkiwi 已提交
628

W
wangchaochaohu 已提交
629
    This OP creates a Tensor with specified `shape` and `dtype`, and
T
tianshuo78520a 已提交
630
    initializes it with a constant specified by `value`.
K
kavyasrinet 已提交
631

T
tianshuo78520a 已提交
632
    The attribute `stop_gradient` of the created Tensor is set to True.
633 634

    Args:
635 636 637 638
        shape(list|tuple|Variable): Shape of the Tensor to be created.
                The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple,
                the elements of it should be integers or Tensors with shape [1].
                If ``shape`` is an Variable, it should be an 1-D Tensor .
W
wangchaochaohu 已提交
639 640
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output tensor which can
            be float16, float32, float64, int32, int64.
641
        value(bool|float|int|Variable): The constant value used to initialize 
W
wangchaochaohu 已提交
642 643
            the Tensor to be created. If value is an Variable, it should be an 1-D Tensor.
        force_cpu(bool): data should be on CPU if it's true, default value is False.
W
wangchaochaohu 已提交
644 645 646
        out(Variable, optional): Optional output which can be any created 
            Variable that meets the requirements to store the result of operation.
            if out is None, a new Varibale will be create to store the result.
647 648
        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`.
649 650

    Returns:
W
wangchaochaohu 已提交
651 652 653 654 655
        Variable: Tensor which is created according to shape and dtype.

    Raise:
        TypeError: The dtype must be one of bool, float16, float32, float64, int32 and int64
        and the data type of out Tensor must be the same as the dtype. 
656 657 658 659

    Examples:
        .. code-block:: python

660
          import paddle.fluid as fluid
661 662 663
          # attr shape is a list which doesn't contain Variable Tensor.
          data1 = fluid.layers.fill_constant(shape=[2,1], value=0, dtype='int64') # data1=[[0],[0]]
          data2 = fluid.layers.fill_constant(shape=[2,1], value=5, dtype='int64', out=data1)
664
          # data1=[[5], [5]] data2=[[5], [5]]
665 666 667 668 669 670

          # attr shape is a list which contains Variable Tensor.
          positive_2 = fluid.layers.fill_constant([1], "int32", 2)
          data3 = fluid.layers.fill_constant(shape=[1, positive_2], dtype='float32', value=1.5) # data3=[1.5, 1.5]

          # attr shape is an Variable Tensor.
671
          shape = fluid.layers.fill_constant([2], "int32", 2) # shape=[2,2]
672
          data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]]
W
wangchaochaohu 已提交
673 674 675 676
          
          # attr value is an Variable Tensor.
          val = fluid.layers.fill_constant([1], "float32", 2.0) # val=[2.0]
          data5 = fluid.layers.fill_constant(shape=[2,1], value=val, dtype='float32') #data5=[[2.0],[2.0]]
Y
Yu Yang 已提交
677
    """
678

W
wangchaochaohu 已提交
679
    attrs = {'force_cpu': force_cpu}
680
    if not isinstance(value, Variable):
W
wangchaochaohu 已提交
681 682 683 684
        if convert_dtype(dtype) in ['int64', 'int32']:
            attrs['str_value'] = str(int(value))
        else:
            attrs['str_value'] = str(float(value))
685 686

    if in_dygraph_mode():
687
        shape = utils._convert_shape_to_list(shape)
688 689
        if out is None:
            out = _varbase_creator(dtype=dtype)
W
wangchaochaohu 已提交
690 691 692 693 694 695 696

        if isinstance(value, Variable):
            if convert_dtype(dtype) in ['int64', 'int32']:
                attrs['str_value'] = str(int(value.numpy()))
            else:
                attrs['str_value'] = str(float(value.numpy()))

697 698
        core.ops.fill_constant(out, 'value',
                               float(value), 'force_cpu', force_cpu, 'dtype',
699 700
                               out.dtype, 'str_value', attrs['str_value'],
                               'shape', shape)
701 702 703
        out.stop_gradient = True
        return out

704 705 706 707 708
    helper = LayerHelper("fill_constant", **locals())
    inputs = {}
    if isinstance(value, Variable):
        inputs['ValueTensor'] = value

709
    check_dtype(dtype, 'dtype',
710 711 712
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'fill_constant')
    check_type(shape, 'shape', (Variable, list, tuple), 'fill_constant')
713

714
    if isinstance(shape, Variable):
715 716
        check_dtype(shape.dtype, 'shape', ['int32', 'int64'], 'fill_constant')

717 718 719 720 721
    if out is not None:
        check_variable_and_dtype(out, 'out', [convert_dtype(dtype)],
                                 'fill_constant')

    helper = LayerHelper("fill_constant", **locals())
722 723
    utils._get_shape_tensor_inputs(
        inputs=inputs, attrs=attrs, shape=shape, op_type='fill_constant')
L
liym27 已提交
724

Y
Yu Yang 已提交
725
    if out is None:
X
Xin Pan 已提交
726
        out = helper.create_variable_for_type_inference(dtype=dtype)
L
liym27 已提交
727
    attrs['dtype'] = out.dtype
Y
Yu Yang 已提交
728 729
    helper.append_op(
        type='fill_constant',
L
liym27 已提交
730
        inputs=inputs,
Y
Yu Yang 已提交
731
        outputs={'Out': [out]},
L
liym27 已提交
732
        attrs=attrs,
M
minqiyang 已提交
733
        stop_gradient=True)
Y
Yu Yang 已提交
734 735 736 737
    out.stop_gradient = True
    return out


Y
yuyang18 已提交
738
@templatedoc()
Y
Yu Yang 已提交
739 740 741 742 743
def fill_constant_batch_size_like(input,
                                  shape,
                                  dtype,
                                  value,
                                  input_dim_idx=0,
G
Guo Sheng 已提交
744 745
                                  output_dim_idx=0,
                                  force_cpu=False):
746
    """
T
tianshuo78520a 已提交
747
    This OP creates a Tesnor according the shape and dtype, and initializes the
W
wangchaochaohu 已提交
748 749 750 751
    Tensor with the constants provided in ``value``. When the input is LoDTensor
    and the input_dim_idx is 0, the output_dim_idx dimension is set to the value
    of the batch_size input by the input, the Stop_gradient attribute of the created
    Tensor is False by default.
752 753

    Args:
W
wangchaochaohu 已提交
754 755 756 757 758 759 760 761 762 763 764
        input(Variable): Tensor which data type is float32, float64, int32 and int64.
        shape(list): The shape of Tensor to be created, Tensor's shape may be changed
            according the input.
        dtype(np.dtype|core.VarDesc.VarType|str): The data type of created Tensor which
            can be float32, float64, int32, int64.
        value(float|int): The constant value used to initialize the Tensor to be created. 
        input_dim_idx(int): When the value is 0 and the input is LoDTensor, the output_dim_idx
            dimension of the created Tensor is set to the batch_size value of input.
            The default value is 0.
        output_dim_idx(int): Used to specify which dimension of Tensor is created to be set
            the value of batch_size of input Tensor. The default value is 0.
T
tianshuo78520a 已提交
765
        force_cpu(bool): data should be on CPU if it's true, default value is False.
Y
yuyang18 已提交
766 767

    Returns:
W
wangchaochaohu 已提交
768
        Variable: Tensor which will be created according to dtype.
H
haowang101779990 已提交
769 770 771 772 773

    Examples:

        .. code-block:: python

774
             import paddle.fluid as fluid
W
wangchaochaohu 已提交
775
             like = fluid.layers.fill_constant(shape=[1,2], value=10, dtype='int64') #like=[[10, 10]]
W
wangchaochaohu 已提交
776
             data = fluid.layers.fill_constant_batch_size_like(
W
wangchaochaohu 已提交
777
                    input=like, shape=[1], value=0, dtype='int64') #like=[[10, 10]] data=[0]
H
haowang101779990 已提交
778

779
    """
Y
Yu Yang 已提交
780
    helper = LayerHelper("fill_constant_batch_size_like", **locals())
X
Xin Pan 已提交
781
    out = helper.create_variable_for_type_inference(dtype=dtype)
782 783 784 785 786 787
    attrs = {
        'shape': shape,
        'dtype': out.dtype,
        'value': float(value),
        'input_dim_idx': input_dim_idx,
        'output_dim_idx': output_dim_idx,
788
        'force_cpu': force_cpu
789 790 791 792 793
    }
    if convert_dtype(dtype) in ['int64', 'int32']:
        attrs['str_value'] = str(int(value))
    else:
        attrs['str_value'] = str(float(value))
Y
Yu Yang 已提交
794 795 796 797
    helper.append_op(
        type='fill_constant_batch_size_like',
        inputs={'Input': input},
        outputs={'Out': [out]},
798
        attrs=attrs)
Y
Yu Yang 已提交
799 800 801 802
    out.stop_gradient = True
    return out


S
sneaxiy 已提交
803 804
def argmin(x, axis=0):
    """
805 806 807
	:alias_main: paddle.argmin
	:alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin
	:old_api: paddle.fluid.layers.argmin
S
swtkiwi 已提交
808

S
sneaxiy 已提交
809 810
    **argmin**

811 812
    This OP computes the indices of the min elements of the input tensor's
    element along the provided axis.
S
sneaxiy 已提交
813 814

    Args:
815 816 817 818 819
        x(Variable): An input N-D Tensor with type float32, float64, int16,
            int32, int64, uint8.
        axis(int, optional): Axis to compute indices along. The effective range
            is [-R, R), where R is Rank(x). when axis<0, it works the same way
            as axis+R. Default is 0.
F
fengjiayi 已提交
820

S
sneaxiy 已提交
821
    Returns:
822
        Variable: A Tensor with data type int64.
F
fengjiayi 已提交
823

S
sneaxiy 已提交
824 825
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
826

827
            import paddle.fluid as fluid
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
            import numpy as np

            in1 = np.array([[[5,8,9,5],
                            [0,0,1,7],
                            [6,9,2,4]],
                            [[5,2,4,2],
                            [4,7,7,9],
                            [1,7,0,6]]])
            with fluid.dygraph.guard():
                x = fluid.dygraph.to_variable(in1)
                out1 = fluid.layers.argmin(x=x, axis=-1)
                out2 = fluid.layers.argmin(x=x, axis=0)
                out3 = fluid.layers.argmin(x=x, axis=1)
                out4 = fluid.layers.argmin(x=x, axis=2)
                print(out1.numpy())
                # [[0 0 2]
                #  [1 0 2]]
                print(out2.numpy())
                # [[0 1 1 1]
                #  [0 0 0 0]
                #  [1 1 1 0]]
                print(out3.numpy())
                # [[1 1 1 2]
                #  [2 0 2 0]]
                print(out4.numpy())
                # [[0 0 2]
                #  [1 0 2]]
S
sneaxiy 已提交
855
    """
856 857 858
    check_variable_and_dtype(
        x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
        'argmin')
S
sneaxiy 已提交
859
    helper = LayerHelper("arg_min", **locals())
X
Xin Pan 已提交
860
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
861 862 863 864 865
    helper.append_op(
        type='arg_min',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
866
    out.stop_gradient = True
S
sneaxiy 已提交
867 868 869 870 871 872 873
    return out


def argmax(x, axis=0):
    """
    **argmax**

874 875
    This OP computes the indices of the max elements of the input tensor's
    element along the provided axis.
S
sneaxiy 已提交
876 877

    Args:
878 879 880 881 882
        x(Variable): An input N-D Tensor with type float32, float64, int16,
            int32, int64, uint8.
        axis(int, optional): Axis to compute indices along. The effective range
            is [-R, R), where R is Rank(x). when axis<0, it works the same way
            as axis+R. Default is 0.
F
fengjiayi 已提交
883

S
sneaxiy 已提交
884
    Returns:
885
        Variable: A Tensor with data type int64.
F
fengjiayi 已提交
886

S
sneaxiy 已提交
887 888
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
889

890
            import paddle.fluid as fluid
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
            import numpy as np

            in1 = np.array([[[5,8,9,5],
                            [0,0,1,7],
                            [6,9,2,4]],
                            [[5,2,4,2],
                            [4,7,7,9],
                            [1,7,0,6]]])
            with fluid.dygraph.guard():
                x = fluid.dygraph.to_variable(in1)
                out1 = fluid.layers.argmax(x=x, axis=-1)
                out2 = fluid.layers.argmax(x=x, axis=0)
                out3 = fluid.layers.argmax(x=x, axis=1)
                out4 = fluid.layers.argmax(x=x, axis=2)
                print(out1.numpy())
                # [[2 3 1]
                #  [0 3 1]]
                print(out2.numpy())
                # [[0 0 0 0]
                #  [1 1 1 1]
                #  [0 0 0 1]]
                print(out3.numpy())
                # [[2 2 0 1]
                #  [0 1 1 1]]
                print(out4.numpy())
                # [[2 3 1]
                #  [0 3 1]]
S
sneaxiy 已提交
918
    """
919 920 921
    check_variable_and_dtype(
        x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
        'argmax')
S
sneaxiy 已提交
922
    helper = LayerHelper("arg_max", **locals())
X
Xin Pan 已提交
923
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
924 925 926 927 928
    helper.append_op(
        type='arg_max',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
929
    out.stop_gradient = True
S
sneaxiy 已提交
930 931 932
    return out


933
def argsort(input, axis=-1, descending=False, name=None):
Y
Yibing Liu 已提交
934
    """
935 936 937
	:alias_main: paddle.argsort
	:alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort
	:old_api: paddle.fluid.layers.argsort
S
swtkiwi 已提交
938

939 940 941
    This OP sorts the input along the given axis, and returns sorted output
    data Varibale and its corresponding index Variable with the same shape as
    :attr:`input`.
Y
Yibing Liu 已提交
942 943

    Args:
944 945 946 947 948
        input(Variable): An input N-D Tensor with type float32, float64, int16,
            int32, int64, uint8.
        axis(int, optional): Axis to compute indices along. The effective range
            is [-R, R), where R is Rank(x). when axis<0, it works the same way
            as axis+R. Default is 0.
949 950 951
        descending(bool, optional) : Descending is a flag, if set to true,
            algorithm will sort by descending order, else sort by
            ascending order. Default is false.
952 953 954
        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`.
Y
Yibing Liu 已提交
955 956

    Returns:
957 958 959
        tuple: A tuple of sorted data Variable(with the same shape and data
        type as input) and the sorted indices(with the same shape as input's
        and with data type int64).
Y
Yibing Liu 已提交
960 961 962 963

    Examples:
        .. code-block:: python

964
            import paddle.fluid as fluid
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
            import numpy as np

            in1 = np.array([[[5,8,9,5],
                            [0,0,1,7],
                            [6,9,2,4]],
                            [[5,2,4,2],
                            [4,7,7,9],
                            [1,7,0,6]]]).astype(np.float32)
            with fluid.dygraph.guard():
                x = fluid.dygraph.to_variable(in1)
                out1 = fluid.layers.argsort(input=x, axis=-1)
                out2 = fluid.layers.argsort(input=x, axis=0)
                out3 = fluid.layers.argsort(input=x, axis=1)
                print(out1[0].numpy())
                # [[[5. 5. 8. 9.]
                #   [0. 0. 1. 7.]
                #   [2. 4. 6. 9.]]
                #  [[2. 2. 4. 5.]
                #   [4. 7. 7. 9.]
                #   [0. 1. 6. 7.]]]
                print(out1[1].numpy())
                # [[[0 3 1 2]
                #   [0 1 2 3]
                #   [2 3 0 1]]
                #  [[1 3 2 0]
                #   [0 1 2 3]
                #   [2 0 3 1]]]
                print(out2[0].numpy())
                # [[[5. 2. 4. 2.]
                #   [0. 0. 1. 7.]
                #   [1. 7. 0. 4.]]
                #  [[5. 8. 9. 5.]
                #   [4. 7. 7. 9.]
                #   [6. 9. 2. 6.]]]
                print(out3[0].numpy())
                # [[[0. 0. 1. 4.]
                #   [5. 8. 2. 5.]
                #   [6. 9. 9. 7.]]
                #  [[1. 2. 0. 2.]
                #   [4. 7. 4. 6.]
                #   [5. 7. 7. 9.]]]
Y
Yibing Liu 已提交
1006
    """
1007 1008 1009
    check_variable_and_dtype(
        input, 'input',
        ['float32', 'float64', 'int16', 'int32', 'int64', 'uint8'], 'argsort')
Y
Yibing Liu 已提交
1010
    helper = LayerHelper("argsort", **locals())
X
Xin Pan 已提交
1011 1012 1013 1014
    out = helper.create_variable_for_type_inference(
        dtype=input.dtype, stop_gradient=True)
    ids = helper.create_variable_for_type_inference(
        VarDesc.VarType.INT64, stop_gradient=True)
Y
Yibing Liu 已提交
1015 1016 1017 1018
    helper.append_op(
        type='argsort',
        inputs={'X': input},
        outputs={'Out': out,
1019
                 'Indices': ids},
1020 1021
        attrs={'axis': axis,
               'descending': descending})
Y
Yibing Liu 已提交
1022 1023 1024
    return out, ids


Y
Yang Yu 已提交
1025
def ones(shape, dtype, force_cpu=False):
Y
Yu Yang 已提交
1026
    """
1027 1028
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 1.
    Its :attr:`stop_gradient` will be set to True to stop gradient computation.
1029

1030 1031 1032 1033 1034 1035 1036
    Parameters:
        shape (tuple|list): Shape of output tensor.
        dtype (np.dtype|core.VarDesc.VarType|str): Data type of output tensor, it supports
            bool, float16, float32, float64, int32 and int64.
        force_cpu (bool, optional): Whether force to store the output tensor in CPU memory.
            If :attr:`force_cpu` is False, the output tensor will be stored in running device memory.
            Default: False.
1037 1038

    Returns:
1039
        Variable: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1.
1040 1041 1042 1043

    Examples:
        .. code-block:: python

1044
          import paddle.fluid as fluid
1045
          data = fluid.layers.ones(shape=[2, 4], dtype='float32') # [[1., 1., 1., 1.], [1., 1., 1., 1.]]
Y
Yu Yang 已提交
1046
    """
1047 1048 1049 1050
    check_type(shape, 'shape', (list, tuple), 'ones')
    check_dtype(dtype, 'create data type',
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'ones')
C
chengduozh 已提交
1051 1052
    assert reduce(lambda x, y: x * y,
                  shape) > 0, "The shape is invalid: %s." % (str(shape))
Y
Yu Yang 已提交
1053 1054 1055
    return fill_constant(value=1.0, **locals())


1056
def zeros(shape, dtype, force_cpu=False, name=None):
Y
Yu Yang 已提交
1057
    """
1058 1059
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0.
    Its :attr:`stop_gradient` will be set to True to stop gradient computation.
1060

1061 1062 1063 1064 1065 1066 1067
    Parameters:
        shape (tuple|list): Shape of output tensor.
        dtype (np.dtype|core.VarDesc.VarType|str): Data type of output tensor, it supports
            bool, float16, float32, float64, int32 and int64.
        force_cpu (bool, optional): Whether force to store the output tensor in CPU memory.
            If :attr:`force_cpu` is False, the output tensor will be stored in running device memory.
            Default: False.
1068 1069
        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`.
1070 1071

    Returns:
1072
        Variable: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0.
1073 1074 1075 1076

    Examples:
        .. code-block:: python

1077
          import paddle.fluid as fluid
1078
          data = fluid.layers.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]]
Y
Yu Yang 已提交
1079 1080
    """
    return fill_constant(value=0.0, **locals())
1081 1082


F
fengjiayi 已提交
1083 1084
def reverse(x, axis):
    """
1085 1086 1087
	:alias_main: paddle.reverse
	:alias: paddle.reverse,paddle.tensor.reverse,paddle.tensor.manipulation.reverse
	:old_api: paddle.fluid.layers.reverse
S
swtkiwi 已提交
1088

1089
    The OP reverses the tensor :attr:`x` along the given :attr:`axis`.
F
fengjiayi 已提交
1090

1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    .. code-block:: text

        Case 1:

            Given a LoDTensor:
                x = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
                axis = [0, 1]

            Then:
                output = [[8, 7, 6], [5, 4, 3], [2, 1, 0]]

        Case 2:

            Given a LoDTensorArray:
                x = {[[0, 1], [2, 3]],
                     [[4, 5, 6]],
                     [[7],[8], [9]]}
                axis = 0

            Then:
                output = {[[7],[8], [9]],
                          [[4, 5, 6]],
                          [[0, 1], [2, 3]]}

1115
    Parameters:
1116 1117
        x (Variable): A tensor or LoDTensorArray to be reversed, its data type supports bool, float32, float64, int32, int64 and uint8.
                      If input is a LoDTensorArray, returns a new reversed LoDTensorArray without changing the internal order of each inner tensor.
1118 1119
        axis (int|tuple|list): A dimension or a set of dimensions of :attr:`x` to reverse. Must be
            in the range [-rank( :attr:`x` ), rank( :attr:`x` )). If it is a tuple or a list, reversing
1120 1121
            will be apply on each axis in the tuple or list. If input is a LoDTensorArray, the value of axis shall be 0, or a
            list [0] or tuple (0, ) with shape [1].
F
fengjiayi 已提交
1122 1123

    Returns:
1124
        Variable: The reversed tensor with the same shape and data type as :attr:`x`.
F
fengjiayi 已提交
1125 1126 1127 1128

    Examples:
        .. code-block:: python

1129
          import paddle.fluid as fluid
1130 1131 1132 1133
          import numpy as np
          data = fluid.layers.assign(np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype='float32')) # [[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]]
          result1 = fluid.layers.reverse(data, 0) # [[6., 7., 8.], [3., 4., 5.], [0., 1., 2.]]
          result2 = fluid.layers.reverse(data, [0, 1]) # [[8., 7., 6.], [5., 4., 3.], [2., 1., 0.]]
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143

          # example of LoDTensorArray
          data1 = fluid.layers.assign(np.array([[0, 1, 2]], dtype='float32'))
          data2 = fluid.layers.assign(np.array([[3, 4, 5]], dtype='float32'))
          tensor_array = fluid.layers.create_array(dtype='float32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
          fluid.layers.array_write(data1, i, tensor_array)
          fluid.layers.array_write(data2, i+1, tensor_array)

          reversed_tensor_array = fluid.layers.reverse(tensor_array, 0) # {[[3, 4, 5]], [[0, 1, 2]]}
F
fengjiayi 已提交
1144
    """
1145 1146 1147
    check_variable_and_dtype(
        x, 'x', ('float32', 'float64', 'int32', 'int64', 'uint8'), 'reverse')
    check_type(axis, 'axis', (int, tuple, list), 'reverse')
F
fengjiayi 已提交
1148 1149 1150
    if isinstance(axis, int):
        axis = [axis]
    helper = LayerHelper("reverse", **locals())
X
Xin Pan 已提交
1151
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
F
fengjiayi 已提交
1152 1153
    helper.append_op(
        type='reverse',
W
Wu Yi 已提交
1154
        inputs={'X': x},
F
fengjiayi 已提交
1155 1156 1157 1158 1159
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


1160 1161 1162 1163 1164 1165 1166
def save(x, file_path, overwrite=True):
    """
    Saves a variable as a file.

    Args:
        x(variable): The Tensor/LoDTensor to be saved.
        file_path(str): The file path where the variable will be saved.
1167 1168 1169
        overwrite(bool): Whether or not cover the given file when it has already
            existed. If it's set 'False' and the file is existed, a runtime
            error will be thrown.
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
    """
    helper = LayerHelper("save", **locals())
    helper.append_op(
        type="save",
        inputs={"input": x},
        outputs={},
        args={"file_path": file_path,
              "overwrite": overwrite})


def save_combine(x, file_path, overwrite=True):
    """
    Saves a list of variables into a single file.

    Args:
1185 1186
        x(list): A list of Tensor/LoDTensor variables to be saved together in
                 a single file.
1187
        file_path(str): The file path where variables will be saved.
1188
        overwrite(bool): Whether or not cover the given file when it has already
1189 1190
            existed. If it's set 'False' and the file is existed, a runtime
            error will be thrown.
1191 1192 1193 1194 1195 1196 1197 1198

    Returns:
        There is no return value.

    Examples:

        .. code-block:: python

1199
            import paddle.fluid as fluid
1200 1201 1202 1203 1204 1205 1206
            v1 = fluid.layers.data(name="data",
                                   shape=(4, 6),
                                   dtype="float32")
            v2 = fluid.layers.data(name="data",
                                   shape=(6, 8, 4),
                                   dtype="float32")
            normed = fluid.layers.save_combine([v1, v2], file_path="output")
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
    """
    helper = LayerHelper("save_combine", **locals())
    helper.append_op(
        type="save_combine",
        inputs={"input": x},
        outputs={},
        args={"file_path": file_path,
              "overwrite": overwrite})


def load_combine(out, file_path):
    """
T
tianshuo78520a 已提交
1219
    Loads a list of variable from a single file.
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230

    Args:
        out(list): The list of variables to be read from the disk file.
        file_path(str): The path of the disk file.
    """
    helper = LayerHelper("load_combine", **locals())
    helper.append_op(
        type="load_combine",
        inputs={},
        output={"Out": out},
        args={"file_path": file_path})
1231 1232 1233 1234


def has_inf(x):
    """
1235 1236 1237
	:alias_main: paddle.has_inf
	:alias: paddle.has_inf,paddle.tensor.has_inf,paddle.tensor.search.has_inf
	:old_api: paddle.fluid.layers.has_inf
S
swtkiwi 已提交
1238

1239 1240 1241
    Test if any of x contains an infinity number

    Args:
L
liu zhengxi 已提交
1242
       x (Variable): The Tensor/LoDTensor to be checked.
1243 1244

    Returns:
L
liu zhengxi 已提交
1245
       Variable: The tensor variable storing the output, only a bool value, indicating that whether there is infinity number in x or not.
1246 1247 1248 1249 1250 1251 1252 1253
    
    Examples:
        .. code-block:: python
          
          import paddle.fluid as fluid
          data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
          res = fluid.layers.has_inf(data)

1254
    """
1255
    check_type(x, 'x', (Variable), 'has_inf')
1256
    helper = LayerHelper("isinf", **locals())
X
Xin Pan 已提交
1257
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
1258 1259 1260 1261 1262 1263
    helper.append_op(type="isinf", inputs={"X": x}, outputs={"Out": out})
    return out


def has_nan(x):
    """
1264 1265 1266
	:alias_main: paddle.has_nan
	:alias: paddle.has_nan,paddle.tensor.has_nan,paddle.tensor.search.has_nan
	:old_api: paddle.fluid.layers.has_nan
S
swtkiwi 已提交
1267

1268 1269 1270
    Test if any of x contains a NAN

    Args:
L
liu zhengxi 已提交
1271
       x (Variable): The Tensor/LoDTensor to be checked.
1272 1273

    Returns:
L
liu zhengxi 已提交
1274
       Variable: The tensor variable storing the output, only a bool value, indicating that whether there is NAN in x or not.
1275 1276 1277 1278 1279 1280 1281 1282
    
    Examples:
        .. code-block:: python
    
          import paddle.fluid as fluid
          data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
          res = fluid.layers.has_nan(data)

1283
    """
1284
    check_type(x, 'x', (Variable), 'has_nan')
1285
    helper = LayerHelper("isnan", **locals())
X
Xin Pan 已提交
1286
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
1287 1288 1289 1290 1291 1292
    helper.append_op(type="isnan", inputs={"X": x}, outputs={"Out": out})
    return out


def isfinite(x):
    """
1293 1294 1295
	:alias_main: paddle.isfinite
	:alias: paddle.isfinite,paddle.tensor.isfinite,paddle.tensor.logic.isfinite
	:old_api: paddle.fluid.layers.isfinite
S
swtkiwi 已提交
1296

1297 1298 1299 1300 1301 1302 1303 1304
    Test if any of x contains an infinity/NAN number. If all the elements are finite,
    returns true, else false.

    Args:
       x(variable): The Tensor/LoDTensor to be checked.

    Returns:
        Variable: The tensor variable storing the output, contains a bool value.
1305 1306 1307 1308 1309

    Examples:

        .. code-block:: python

1310
            import paddle.fluid as fluid
1311 1312 1313
            var = fluid.layers.data(name="data",
                                    shape=(4, 6),
                                    dtype="float32")
石晓伟 已提交
1314
            out = fluid.layers.isfinite(var)
1315
    """
1316 1317
    check_variable_and_dtype(x, "x", ["float32", "float64", "int32", "int64"],
                             "isfinite")
1318
    helper = LayerHelper("isfinite", **locals())
1319

1320
    out = helper.create_variable_for_type_inference(dtype='bool')
1321 1322
    helper.append_op(type="isfinite", inputs={"X": x}, outputs={"Out": out})
    return out
W
whs 已提交
1323 1324 1325 1326 1327 1328 1329 1330 1331


def range(start, end, step, dtype):
    """
    Return evenly spaced values within a given interval.

    Values are generated within the half-open interval [start, stop) (in other words,
    the interval including start but excluding stop).

L
Liufang Sang 已提交
1332 1333 1334 1335
    Parameters:
        start(float32 | float64 | int32 | int64 | Variable): Start of interval. The interval includes this value.
            when start is Variable, it is a 1-D Tensor with shape [1].
        end(float32 | float64 | int32 | int64 | Variable): End of interval. The interval does not include this
W
whs 已提交
1336
                                 value, except in some cases where step is not an integer
L
Liufang Sang 已提交
1337 1338 1339
                                 and floating point round-off affects the length of out. When end is Variable,
                                 it is a 1-D Tensor with shape [1].
        step(float32 | float64 | int32 | int64 | Variable): Spacing between values. For any output out, this is the
W
whs 已提交
1340
                                  distance between two adjacent values, out[i+1] - out[i].
1341
        dtype(str|core.VarDesc.VarType): the data type of the output tensor, can be float32, float64, int32, int64.
W
whs 已提交
1342

L
Liufang Sang 已提交
1343 1344 1345
    Returns: a 1-D Tensor which is evenly spaced values within a given interval. Its data type is set by dtype.
    
    Return type: Variable
W
whs 已提交
1346 1347 1348 1349 1350

    examples:

        .. code-block:: python

1351
             import paddle.fluid as fluid
W
whs 已提交
1352 1353 1354
             data = fluid.layers.range(0, 10, 2, 'int32')

    """
1355 1356 1357
    check_type(start, 'start', (float, int, Variable), 'range')
    check_type(end, 'end', (float, int, Variable), 'range')
    check_type(step, 'step', (float, int, Variable), 'range')
W
whs 已提交
1358 1359
    helper = LayerHelper("range", **locals())

1360 1361 1362 1363
    check_dtype(dtype, 'create data type',
                ['float32', 'float64', 'int32', 'int64'], 'range')

    dtype = convert_dtype(dtype)
W
whs 已提交
1364 1365
    if not isinstance(start, Variable):
        start = fill_constant([1], dtype, start)
1366 1367 1368 1369 1370
    elif convert_dtype(start.dtype) != dtype:
        # make sure that start, end, step has the same dtype as
        # `dtype`
        start = cast(x=start, dtype=dtype)

W
whs 已提交
1371 1372
    if not isinstance(end, Variable):
        end = fill_constant([1], dtype, end)
1373 1374 1375
    elif convert_dtype(end.dtype) != dtype:
        end = cast(x=end, dtype=dtype)

W
whs 已提交
1376 1377
    if not isinstance(step, Variable):
        step = fill_constant([1], dtype, step)
1378 1379
    elif convert_dtype(step.dtype) != dtype:
        step = cast(x=step, dtype=dtype)
W
whs 已提交
1380 1381 1382 1383 1384 1385 1386 1387 1388

    out = helper.create_variable_for_type_inference(dtype=start.dtype)

    helper.append_op(
        type='range',
        inputs={'Start': start,
                'End': end,
                'Step': step},
        outputs={'Out': [out]})
1389
    out.stop_gradient = True
W
whs 已提交
1390
    return out
Z
zhoukunsheng 已提交
1391 1392


1393
def linspace(start, stop, num, dtype=None, name=None):
Z
zhoukunsheng 已提交
1394
    """
1395
    This OP return fixed number of evenly spaced values within a given interval.
Z
zhoukunsheng 已提交
1396 1397

    Args:
1398 1399 1400 1401 1402 1403
        start(float|Variable): The input :attr:`start` is start variable of range. It is a float scalar, \
            or a tensor of shape [1] with input data type float32, float64.
        stop(float|Variable): The input :attr:`stop` is start variable of range. It is a float scalar, \
            or a tensor of shape [1] with input data type float32, float64.
        num(int|Variable): The input :attr:`num` is given num of the sequence. It is an int scalar, \
            or a tensor of shape [1] with type int32.
1404 1405 1406 1407
        dtype(np.dtype|core.VarDesc.VarType|str): The data type of output tensor, it could be 'float32' and 'float64'.
            Default: if None, the data type is `float32`.
        name(str, optional): Normally there is no need for user to set this property. 
            For more information, please refer to :ref:`api_guide_Name`.Default: None.
Z
zhoukunsheng 已提交
1408 1409

    Returns:
1410 1411 1412
        Variable, the output data type will be float32, float64.: The 1-D tensor with fixed number of evenly spaced values, \
        the data shape of this tensor is :math:`[num]` . If the :attr:`num` is set 1, the output tensor just has \
        the value with input :attr:`start`. 
Z
zhoukunsheng 已提交
1413

Z
zhoukunsheng 已提交
1414
    Examples:
Z
zhoukunsheng 已提交
1415 1416
        .. code-block:: python

1417
             import paddle.fluid as fluid
Z
zhoukunsheng 已提交
1418 1419
             data = fluid.layers.linspace(0, 10, 5, 'float32') # [0.0,  2.5,  5.0,  7.5, 10.0]
             data = fluid.layers.linspace(0, 10, 1, 'float32') # [0.0]
Z
zhoukunsheng 已提交
1420 1421

    """
1422 1423
    if dtype is None:
        dtype = 'float32'
Z
zhoukunsheng 已提交
1424 1425 1426 1427 1428 1429
    if not isinstance(start, Variable):
        start = fill_constant([1], dtype, start)
    if not isinstance(stop, Variable):
        stop = fill_constant([1], dtype, stop)
    if not isinstance(num, Variable):
        num = fill_constant([1], 'int32', num)
1430 1431 1432 1433 1434 1435 1436 1437 1438
    if in_dygraph_mode():
        return core.ops.linspace(start, stop, num)

    helper = LayerHelper("linspace", **locals())

    check_dtype(start.dtype, 'start', ['float32', 'float64'], 'linspace')
    check_dtype(stop.dtype, 'stop', ['float32', 'float64'], 'linspace')
    check_dtype(num.dtype, 'num', ['int32', 'int64'], 'linspace')
    check_dtype(dtype, 'dtype', ['float32', 'float64'], 'linspace')
Z
zhoukunsheng 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448

    out = helper.create_variable_for_type_inference(dtype=start.dtype)

    helper.append_op(
        type='linspace',
        inputs={'Start': start,
                'Stop': stop,
                'Num': num},
        outputs={'Out': [out]})
    return out
1449 1450


Z
zhoukunsheng 已提交
1451 1452
def zeros_like(x, out=None):
    """
1453
    This OP creates a zeros tensor which has identical shape and dtype 
Z
zhoukunsheng 已提交
1454 1455 1456
    with `x`.

    Args:
1457 1458 1459 1460 1461 1462
        x(Variable): The input tensor which specifies shape and dtype, the
            input data dtype could be bool, float32, float64, int32, int64.
        out(Variable, optional): If is :attr:`None` , the op will create the
            variable as output, the data type and shape of this variable will
            be same as input :attr:`x`. If is a tensor, the data type and shape
            need to be same as input :attr:`x`. The default value is :attr:`None` .
Z
zhoukunsheng 已提交
1463 1464

    Returns:
1465 1466 1467
        Variable: The N-D tensor, the element in tensor is related to input
            data type, if the input data type is bool, the output value is
            False, otherwise is zero. The output shape is the same as the input.
Z
zhoukunsheng 已提交
1468 1469 1470 1471

    Examples:
        .. code-block:: python

1472
          import paddle.fluid as fluid
1473
          x = fluid.data(name='x', dtype='float32', shape=[3])
Z
zhoukunsheng 已提交
1474 1475
          data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]

Z
zhoukunsheng 已提交
1476 1477
    """

1478 1479
    check_variable_and_dtype(
        x, "x", ['bool', 'float32', 'float64', 'int32', 'int64'], 'ones_like')
Z
zhoukunsheng 已提交
1480 1481 1482
    helper = LayerHelper("zeros_like", **locals())
    if out is None:
        out = helper.create_variable_for_type_inference(dtype=x.dtype)
1483 1484 1485
    else:
        check_variable_and_dtype(
            out, "out", ['bool', 'float32', 'float64', 'int32', 'int64'],
1486
            'zeros_like')
1487

Z
zhoukunsheng 已提交
1488 1489 1490 1491
    helper.append_op(
        type='fill_zeros_like', inputs={'X': [x]}, outputs={'Out': [out]})
    out.stop_gradient = True
    return out
Z
zhoukunsheng 已提交
1492 1493 1494 1495


def diag(diagonal):
    """
1496 1497 1498
	:alias_main: paddle.diag
	:alias: paddle.diag,paddle.tensor.diag,paddle.tensor.creation.diag
	:old_api: paddle.fluid.layers.diag
S
swtkiwi 已提交
1499

1500
    This OP creates a square matrix which has diagonal values specified by input :attr:`diagonal`.
Z
zhoukunsheng 已提交
1501 1502

    Args:
1503 1504
        diagonal(Variable|numpy.ndarray): The input tensor should be 1D tensor, the input shape is :math:`[ N]` , \
            specifying diagonal values by this input tensor. The input data type should be float32, float64, int32, int64.
Z
zhoukunsheng 已提交
1505 1506

    Returns:
1507 1508
        Variable, the output data type is the same as input data type.: The tensor variable storing the square matrix, \
            the diagonal values specified by input :attr:`diagonal`. the output shape is :math:`[N, N]` with two dims.
Z
zhoukunsheng 已提交
1509 1510 1511 1512 1513 1514 1515

    Examples:
        .. code-block:: python

          # [[3, 0, 0]
          #  [0, 4, 0]
          #  [0, 0, 5] 
1516 1517 1518

          import paddle.fluid as fluid
          import numpy as np
1519 1520 1521
          diagonal = np.arange(3, 6, dtype='int32')
          data = fluid.layers.diag(diagonal)
          # diagonal.shape=(3,) data.shape=(3, 3)
Z
zhoukunsheng 已提交
1522 1523

    """
1524 1525 1526
    check_type(diagonal, 'diagonal', (Variable, numpy.ndarray), 'diag')
    check_dtype(diagonal.dtype, 'diagonal',
                ['float32', 'float64', 'int32', 'int64'], 'diag')
Z
zhoukunsheng 已提交
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
    helper = LayerHelper("diag", **locals())

    if not isinstance(diagonal, Variable):
        diagonal = assign(diagonal)

    out = helper.create_variable_for_type_inference(dtype=diagonal.dtype)

    helper.append_op(
        type='diag', inputs={'Diagonal': [diagonal]}, outputs={'Out': [out]})

    out.stop_gradient = True
    return out
Z
zhoukunsheng 已提交
1539 1540


1541 1542
def eye(num_rows, num_columns=None, batch_shape=None, dtype='float32'):
    """
1543 1544 1545
	:alias_main: paddle.eye
	:alias: paddle.eye,paddle.tensor.eye,paddle.tensor.creation.eye
	:old_api: paddle.fluid.layers.eye
S
swtkiwi 已提交
1546

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
    **eye**

    This function constructs an identity tensor, or a batch of tensor.

    Args:
        num_rows(int): the number of rows in each batch tensor.
        num_columns(int): the number of columns in each batch tensor.
                          If None, default: num_rows.
        batch_shape(list(int)): If provided, the returned tensor will have a leading
                                batch size of this shape.
1557 1558
        dtype(string): The data type of the returned tensor.
                       It should be int32, int64, float16, float32, float64.
1559 1560

    Returns:
1561
        Variable: An identity Tensor or LoDTensor of shape batch_shape + [num_rows, num_columns].
1562 1563 1564 1565 1566

    Examples:
        .. code-block:: python

          import paddle.fluid as fluid
1567 1568
          data = fluid.layers.eye(3, dtype='int32')
          # [[1, 0, 0]
1569
          #  [0, 1, 0]
1570 1571
          #  [0, 0, 1]]

1572
          data = fluid.layers.eye(2, 3, dtype='int32')
1573
          # [[1, 0, 0]
1574
          #  [0, 1, 0]]
1575 1576

          data = fluid.layers.eye(2, batch_shape=[3])
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
          # Construct a batch of 3 identity tensors, each 2 x 2.
          # data[i, :, :] is a 2 x 2 identity tensor, i = 0, 1, 2.

    """

    helper = LayerHelper("eye", **locals())
    if not isinstance(num_rows, int) or num_rows < 0:
        raise TypeError("num_rows should be a non-negative int")
    if num_columns is not None:
        if not isinstance(num_columns, int) or num_columns < 0:
            raise TypeError("num_columns should be a non-negative int")
    else:
        num_columns = num_rows
    out = helper.create_variable_for_type_inference(dtype=dtype)
    c_dtype = convert_np_dtype_to_dtype_(dtype)
    helper.append_op(
        type='eye',
        inputs={},
        outputs={'Out': [out]},
        attrs={
            'num_rows': num_rows,
            'num_columns': num_columns,
            'dtype': c_dtype
        },
        stop_gradient=True)
    out.stop_gradient = True

    if batch_shape is not None:
        if not isinstance(batch_shape, list):
            raise TypeError("batch_shape should be a list")
        from .nn import stack
        for batch_val in reversed(batch_shape):
            if batch_val <= 0:
                raise TypeError("batch_shape should be a positive int list")
            else:
                stack_vars = [out for _ in numpy.arange(batch_val)]
                out = stack(stack_vars, axis=0)
    return out


Z
zhoukunsheng 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
def ones_like(x, out=None):
    """
    **ones_like**

    This function creates a ones tensor which has identical shape and dtype 
    with `x`.

    Args:
        x(Variable): The input tensor which specifies shape and dtype.
        out(Variable): The output tensor.

    Returns:
1629
        out(Variable): The tensor variable storing the output.
Z
zhoukunsheng 已提交
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639

    Examples:
        .. code-block:: python

          import paddle.fluid as fluid

          x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
          data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0]

    """
1640 1641
    check_variable_and_dtype(
        x, "x", ['bool', 'float32', 'float64', 'int32', 'int64'], 'ones_like')
Z
zhoukunsheng 已提交
1642 1643 1644 1645

    helper = LayerHelper("ones_like", **locals())
    if out is None:
        out = helper.create_variable_for_type_inference(dtype=x.dtype)
1646 1647 1648 1649
    else:
        check_variable_and_dtype(
            out, "out", ['bool', 'float32', 'float64', 'int32', 'int64'],
            'ones_like')
Z
zhoukunsheng 已提交
1650 1651 1652 1653 1654 1655
    helper.append_op(
        type='fill_any_like',
        inputs={'X': [x]},
        attrs={'value': 1.0},
        outputs={'Out': [out]})
    return out