tensor.py 60.9 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


Q
QI JUN 已提交
623
def fill_constant(shape, dtype, value, force_cpu=False, out=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.
W
wangchaochaohu 已提交
641 642 643
        value(float16|float32|float64|int32|int64|Variable): The constant value used to initialize 
            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

    Returns:
W
wangchaochaohu 已提交
649 650 651 652 653
        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. 
654 655 656 657

    Examples:
        .. code-block:: python

658
          import paddle.fluid as fluid
659 660 661
          # 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)
662
          # data1=[[5], [5]] data2=[[5], [5]]
663 664 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.
          shape = fluid.layers.fill_constant([1,2], "int32", 2) # shape=[2,2]
          data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]]
W
wangchaochaohu 已提交
671 672 673 674
          
          # 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 已提交
675
    """
W
wangchaochaohu 已提交
676 677 678 679
    inputs = {}
    attrs = {'force_cpu': force_cpu}
    if isinstance(value, Variable):
        inputs['ValueTensor'] = value
680
    else:
W
wangchaochaohu 已提交
681 682 683 684 685
        attrs['value'] = float(value)
        if convert_dtype(dtype) in ['int64', 'int32']:
            attrs['str_value'] = str(int(value))
        else:
            attrs['str_value'] = str(float(value))
686 687

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

        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()))

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

705
    check_dtype(dtype, 'dtype',
706 707 708
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'fill_constant')
    check_type(shape, 'shape', (Variable, list, tuple), 'fill_constant')
709 710 711 712 713 714 715 716
    if isinstance(shape, Variable):
        check_variable_and_dtype(shape, 'shape', ['int32', 'int64'],
                                 'fill_constant')
    if out is not None:
        check_variable_and_dtype(out, 'out', [convert_dtype(dtype)],
                                 'fill_constant')

    helper = LayerHelper("fill_constant", **locals())
717 718
    utils._get_shape_tensor_inputs(
        inputs=inputs, attrs=attrs, shape=shape, op_type='fill_constant')
L
liym27 已提交
719

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


Y
yuyang18 已提交
733
@templatedoc()
Y
Yu Yang 已提交
734 735 736 737 738
def fill_constant_batch_size_like(input,
                                  shape,
                                  dtype,
                                  value,
                                  input_dim_idx=0,
G
Guo Sheng 已提交
739 740
                                  output_dim_idx=0,
                                  force_cpu=False):
741
    """
T
tianshuo78520a 已提交
742
    This OP creates a Tesnor according the shape and dtype, and initializes the
W
wangchaochaohu 已提交
743 744 745 746
    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.
747 748

    Args:
W
wangchaochaohu 已提交
749 750 751 752 753 754 755 756 757 758 759
        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 已提交
760
        force_cpu(bool): data should be on CPU if it's true, default value is False.
Y
yuyang18 已提交
761 762

    Returns:
W
wangchaochaohu 已提交
763
        Variable: Tensor which will be created according to dtype.
H
haowang101779990 已提交
764 765 766 767 768

    Examples:

        .. code-block:: python

769
             import paddle.fluid as fluid
W
wangchaochaohu 已提交
770
             like = fluid.layers.fill_constant(shape=[1,2], value=10, dtype='int64') #like=[[10, 10]]
W
wangchaochaohu 已提交
771
             data = fluid.layers.fill_constant_batch_size_like(
W
wangchaochaohu 已提交
772
                    input=like, shape=[1], value=0, dtype='int64') #like=[[10, 10]] data=[0]
H
haowang101779990 已提交
773

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


S
sneaxiy 已提交
798 799
def argmin(x, axis=0):
    """
800 801 802
	:alias_main: paddle.argmin
	:alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin
	:old_api: paddle.fluid.layers.argmin
S
swtkiwi 已提交
803

S
sneaxiy 已提交
804 805
    **argmin**

806 807
    This OP computes the indices of the min elements of the input tensor's
    element along the provided axis.
S
sneaxiy 已提交
808 809

    Args:
810 811 812 813 814
        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 已提交
815

S
sneaxiy 已提交
816
    Returns:
817
        Variable: A Tensor with data type int64.
F
fengjiayi 已提交
818

S
sneaxiy 已提交
819 820
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
821

822
            import paddle.fluid as fluid
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
            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 已提交
850
    """
851 852 853
    check_variable_and_dtype(
        x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
        'argmin')
S
sneaxiy 已提交
854
    helper = LayerHelper("arg_min", **locals())
X
Xin Pan 已提交
855
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
856 857 858 859 860
    helper.append_op(
        type='arg_min',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
861
    out.stop_gradient = True
S
sneaxiy 已提交
862 863 864 865 866 867 868
    return out


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

869 870
    This OP computes the indices of the max elements of the input tensor's
    element along the provided axis.
S
sneaxiy 已提交
871 872

    Args:
873 874 875 876 877
        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 已提交
878

S
sneaxiy 已提交
879
    Returns:
880
        Variable: A Tensor with data type int64.
F
fengjiayi 已提交
881

S
sneaxiy 已提交
882 883
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
884

885
            import paddle.fluid as fluid
886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
            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 已提交
913
    """
914 915 916
    check_variable_and_dtype(
        x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
        'argmax')
S
sneaxiy 已提交
917
    helper = LayerHelper("arg_max", **locals())
X
Xin Pan 已提交
918
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
919 920 921 922 923
    helper.append_op(
        type='arg_max',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
924
    out.stop_gradient = True
S
sneaxiy 已提交
925 926 927
    return out


928
def argsort(input, axis=-1, descending=False, name=None):
Y
Yibing Liu 已提交
929
    """
930 931 932
	:alias_main: paddle.argsort
	:alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort
	:old_api: paddle.fluid.layers.argsort
S
swtkiwi 已提交
933

934 935 936
    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 已提交
937 938

    Args:
939 940 941 942 943
        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.
944 945 946
        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.
947 948 949
        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 已提交
950 951

    Returns:
952 953 954
        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 已提交
955 956 957 958

    Examples:
        .. code-block:: python

959
            import paddle.fluid as fluid
960 961 962 963 964 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
            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 已提交
1001
    """
1002 1003 1004
    check_variable_and_dtype(
        input, 'input',
        ['float32', 'float64', 'int16', 'int32', 'int64', 'uint8'], 'argsort')
Y
Yibing Liu 已提交
1005
    helper = LayerHelper("argsort", **locals())
X
Xin Pan 已提交
1006 1007 1008 1009
    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 已提交
1010 1011 1012 1013
    helper.append_op(
        type='argsort',
        inputs={'X': input},
        outputs={'Out': out,
1014
                 'Indices': ids},
1015 1016
        attrs={'axis': axis,
               'descending': descending})
Y
Yibing Liu 已提交
1017 1018 1019
    return out, ids


Y
Yang Yu 已提交
1020
def ones(shape, dtype, force_cpu=False):
Y
Yu Yang 已提交
1021
    """
1022 1023
    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.
1024

1025 1026 1027 1028 1029 1030 1031
    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.
1032 1033

    Returns:
1034
        Variable: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1.
1035 1036 1037 1038

    Examples:
        .. code-block:: python

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


Y
Yang Yu 已提交
1051
def zeros(shape, dtype, force_cpu=False):
Y
Yu Yang 已提交
1052
    """
1053 1054
    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.
1055

1056 1057 1058 1059 1060 1061 1062
    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.
1063 1064

    Returns:
1065
        Variable: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0.
1066 1067 1068 1069

    Examples:
        .. code-block:: python

1070
          import paddle.fluid as fluid
1071
          data = fluid.layers.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]]
Y
Yu Yang 已提交
1072
    """
1073
    check_type(shape, 'shape', (list, tuple), 'zeros')
1074 1075 1076
    check_dtype(dtype, 'create data type',
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'zeros')
Y
Yu Yang 已提交
1077
    return fill_constant(value=0.0, **locals())
1078 1079


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

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

1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
    .. 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]]}

1112
    Parameters:
1113 1114
        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.
1115 1116
        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
1117 1118
            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 已提交
1119 1120

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

    Examples:
        .. code-block:: python

1126
          import paddle.fluid as fluid
1127 1128 1129 1130
          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.]]
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140

          # 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 已提交
1141
    """
1142 1143 1144
    check_variable_and_dtype(
        x, 'x', ('float32', 'float64', 'int32', 'int64', 'uint8'), 'reverse')
    check_type(axis, 'axis', (int, tuple, list), 'reverse')
F
fengjiayi 已提交
1145 1146 1147
    if isinstance(axis, int):
        axis = [axis]
    helper = LayerHelper("reverse", **locals())
X
Xin Pan 已提交
1148
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
F
fengjiayi 已提交
1149 1150
    helper.append_op(
        type='reverse',
W
Wu Yi 已提交
1151
        inputs={'X': x},
F
fengjiayi 已提交
1152 1153 1154 1155 1156
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


1157 1158 1159 1160 1161 1162 1163
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.
1164 1165 1166
        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.
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
    """
    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:
1182 1183
        x(list): A list of Tensor/LoDTensor variables to be saved together in
                 a single file.
1184
        file_path(str): The file path where variables will be saved.
1185
        overwrite(bool): Whether or not cover the given file when it has already
1186 1187
            existed. If it's set 'False' and the file is existed, a runtime
            error will be thrown.
1188 1189 1190 1191 1192 1193 1194 1195

    Returns:
        There is no return value.

    Examples:

        .. code-block:: python

1196
            import paddle.fluid as fluid
1197 1198 1199 1200 1201 1202 1203
            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")
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
    """
    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 已提交
1216
    Loads a list of variable from a single file.
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227

    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})
1228 1229 1230 1231


def has_inf(x):
    """
1232 1233 1234
	: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 已提交
1235

1236 1237 1238
    Test if any of x contains an infinity number

    Args:
L
liu zhengxi 已提交
1239
       x (Variable): The Tensor/LoDTensor to be checked.
1240 1241

    Returns:
L
liu zhengxi 已提交
1242
       Variable: The tensor variable storing the output, only a bool value, indicating that whether there is infinity number in x or not.
1243 1244 1245 1246 1247 1248 1249 1250
    
    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)

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


def has_nan(x):
    """
1261 1262 1263
	: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 已提交
1264

1265 1266 1267
    Test if any of x contains a NAN

    Args:
L
liu zhengxi 已提交
1268
       x (Variable): The Tensor/LoDTensor to be checked.
1269 1270

    Returns:
L
liu zhengxi 已提交
1271
       Variable: The tensor variable storing the output, only a bool value, indicating that whether there is NAN in x or not.
1272 1273 1274 1275 1276 1277 1278 1279
    
    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)

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


def isfinite(x):
    """
1290 1291 1292
	:alias_main: paddle.isfinite
	:alias: paddle.isfinite,paddle.tensor.isfinite,paddle.tensor.logic.isfinite
	:old_api: paddle.fluid.layers.isfinite
S
swtkiwi 已提交
1293

1294 1295 1296 1297 1298 1299 1300 1301
    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.
1302 1303 1304 1305 1306

    Examples:

        .. code-block:: python

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

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


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 已提交
1329 1330 1331 1332
    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 已提交
1333
                                 value, except in some cases where step is not an integer
L
Liufang Sang 已提交
1334 1335 1336
                                 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 已提交
1337
                                  distance between two adjacent values, out[i+1] - out[i].
1338
        dtype(str|core.VarDesc.VarType): the data type of the output tensor, can be float32, float64, int32, int64.
W
whs 已提交
1339

L
Liufang Sang 已提交
1340 1341 1342
    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 已提交
1343 1344 1345 1346 1347

    examples:

        .. code-block:: python

1348
             import paddle.fluid as fluid
W
whs 已提交
1349 1350 1351
             data = fluid.layers.range(0, 10, 2, 'int32')

    """
1352 1353 1354
    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 已提交
1355 1356
    helper = LayerHelper("range", **locals())

1357 1358 1359 1360
    check_dtype(dtype, 'create data type',
                ['float32', 'float64', 'int32', 'int64'], 'range')

    dtype = convert_dtype(dtype)
W
whs 已提交
1361 1362
    if not isinstance(start, Variable):
        start = fill_constant([1], dtype, start)
1363 1364 1365 1366 1367
    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 已提交
1368 1369
    if not isinstance(end, Variable):
        end = fill_constant([1], dtype, end)
1370 1371 1372
    elif convert_dtype(end.dtype) != dtype:
        end = cast(x=end, dtype=dtype)

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

    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]})
1386
    out.stop_gradient = True
W
whs 已提交
1387
    return out
Z
zhoukunsheng 已提交
1388 1389


Z
zhoukunsheng 已提交
1390 1391
def linspace(start, stop, num, dtype):
    """
1392
    This OP return fixed number of evenly spaced values within a given interval.
Z
zhoukunsheng 已提交
1393 1394

    Args:
1395 1396 1397 1398 1399 1400 1401
        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.
        dtype(string): The data type of output tensor, it could be 'float32' and 'float64'.
Z
zhoukunsheng 已提交
1402 1403

    Returns:
1404 1405 1406
        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 已提交
1407

Z
zhoukunsheng 已提交
1408
    Examples:
Z
zhoukunsheng 已提交
1409 1410
        .. code-block:: python

1411
             import paddle.fluid as fluid
Z
zhoukunsheng 已提交
1412 1413
             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 已提交
1414 1415 1416 1417

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

1418 1419 1420 1421
    check_type(start, 'start', (Variable, float, int), linspace)
    check_type(stop, 'stop', (Variable, float, int), linspace)
    check_type(num, 'num', (Variable, float, int), linspace)

Z
zhoukunsheng 已提交
1422 1423
    if not isinstance(start, Variable):
        start = fill_constant([1], dtype, start)
1424 1425 1426 1427
    else:
        check_variable_and_dtype(start, "start", ["float32", "float64"],
                                 "linspace")

Z
zhoukunsheng 已提交
1428 1429
    if not isinstance(stop, Variable):
        stop = fill_constant([1], dtype, stop)
1430 1431 1432
    else:
        check_variable_and_dtype(stop, "stop", ["float32", "float64"],
                                 "linspace")
Z
zhoukunsheng 已提交
1433 1434
    if not isinstance(num, Variable):
        num = fill_constant([1], 'int32', num)
1435 1436
    else:
        check_variable_and_dtype(num, "num", ["int32"], "linspace")
Z
zhoukunsheng 已提交
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446

    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
1447 1448


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

    Args:
1455 1456 1457
        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`. 
T
tianshuo78520a 已提交
1458
            The default value is :attr:`None` .
Z
zhoukunsheng 已提交
1459 1460

    Returns:
1461 1462
        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 已提交
1463 1464 1465 1466

    Examples:
        .. code-block:: python

1467
          import paddle.fluid as fluid
1468
          x = fluid.data(name='x', dtype='float32', shape=[3])
Z
zhoukunsheng 已提交
1469 1470
          data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]

Z
zhoukunsheng 已提交
1471 1472
    """

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

Z
zhoukunsheng 已提交
1483 1484 1485 1486
    helper.append_op(
        type='fill_zeros_like', inputs={'X': [x]}, outputs={'Out': [out]})
    out.stop_gradient = True
    return out
Z
zhoukunsheng 已提交
1487 1488 1489 1490


def diag(diagonal):
    """
1491 1492 1493
	:alias_main: paddle.diag
	:alias: paddle.diag,paddle.tensor.diag,paddle.tensor.creation.diag
	:old_api: paddle.fluid.layers.diag
S
swtkiwi 已提交
1494

1495
    This OP creates a square matrix which has diagonal values specified by input :attr:`diagonal`.
Z
zhoukunsheng 已提交
1496 1497

    Args:
1498 1499
        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 已提交
1500 1501

    Returns:
1502 1503
        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 已提交
1504 1505 1506 1507 1508 1509 1510

    Examples:
        .. code-block:: python

          # [[3, 0, 0]
          #  [0, 4, 0]
          #  [0, 0, 5] 
1511 1512 1513

          import paddle.fluid as fluid
          import numpy as np
1514 1515 1516
          diagonal = np.arange(3, 6, dtype='int32')
          data = fluid.layers.diag(diagonal)
          # diagonal.shape=(3,) data.shape=(3, 3)
Z
zhoukunsheng 已提交
1517 1518

    """
1519 1520 1521
    check_type(diagonal, 'diagonal', (Variable, numpy.ndarray), 'diag')
    check_dtype(diagonal.dtype, 'diagonal',
                ['float32', 'float64', 'int32', 'int64'], 'diag')
Z
zhoukunsheng 已提交
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
    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 已提交
1534 1535


1536 1537
def eye(num_rows, num_columns=None, batch_shape=None, dtype='float32'):
    """
1538 1539 1540
	:alias_main: paddle.eye
	:alias: paddle.eye,paddle.tensor.eye,paddle.tensor.creation.eye
	:old_api: paddle.fluid.layers.eye
S
swtkiwi 已提交
1541

1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
    **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.
1552 1553
        dtype(string): The data type of the returned tensor.
                       It should be int32, int64, float16, float32, float64.
1554 1555

    Returns:
1556
        Variable: An identity Tensor or LoDTensor of shape batch_shape + [num_rows, num_columns].
1557 1558 1559 1560 1561

    Examples:
        .. code-block:: python

          import paddle.fluid as fluid
1562 1563
          data = fluid.layers.eye(3, dtype='int32')
          # [[1, 0, 0]
1564
          #  [0, 1, 0]
1565 1566
          #  [0, 0, 1]]

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

          data = fluid.layers.eye(2, batch_shape=[3])
1572 1573 1574 1575 1576 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
          # 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 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
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:
1624
        out(Variable): The tensor variable storing the output.
Z
zhoukunsheng 已提交
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634

    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]

    """
1635 1636
    check_variable_and_dtype(
        x, "x", ['bool', 'float32', 'float64', 'int32', 'int64'], 'ones_like')
Z
zhoukunsheng 已提交
1637 1638 1639 1640

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