creation.py 42.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

P
Pei Yang 已提交
15
from __future__ import print_function
16 17
import numpy as np

L
Li Fuchen 已提交
18
from ..fluid.framework import Variable
19 20 21
from ..fluid.framework import unique_name
from ..fluid.framework import _current_expected_place
from ..fluid.framework import dygraph_only
P
Pei Yang 已提交
22 23 24 25 26
from ..fluid.initializer import Constant
from ..fluid.layers import core
from ..fluid.layer_helper import LayerHelper
from ..fluid.data_feeder import check_variable_and_dtype, check_type, check_dtype, convert_dtype
from ..fluid.framework import convert_np_dtype_to_dtype_, in_dygraph_mode, _varbase_creator, device_guard, OpProtoHolder
27
from paddle.common_ops_import import *
W
wangchaochaohu 已提交
28

29
# TODO: define functions to get create a tensor  
30
from ..fluid.layers import linspace  #DEFINE_ALIAS
31
import paddle
32

W
wangchaochaohu 已提交
33
__all__ = [
34
    'to_tensor',
35 36
    'diag',
    #       'get_tensor_from_selected_rows',
37
    'linspace',
38 39 40 41
    'ones',
    'ones_like',
    'zeros',
    'zeros_like',
42
    'arange',
43
    'eye',
W
wangchaochaohu 已提交
44
    'full',
P
Pei Yang 已提交
45
    'full_like',
46
    'empty',
47
    'empty_like',
W
WuHaobo 已提交
48 49
    'triu',
    'tril',
50 51
    'meshgrid',
    'assign',
W
wangchaochaohu 已提交
52 53 54
]


55 56 57 58 59 60 61 62
@dygraph_only
def to_tensor(data, dtype=None, place=None, stop_gradient=True):
    """
    Constructs a ``paddle.Tensor`` or ``paddle.ComplexTensor`` from ``data`` , 
    which can be scalar, tuple, list, numpy\.ndarray, paddle\.Tensor, paddle\.ComplexTensor.

    If the ``data`` is already a tensor, and ``dtype`` or ``place`` does't change, no copy 
    will be performed and return origin tensor, otherwise a new tensor will be constructed
L
Leo Chen 已提交
63
    and returned. 
64 65 66 67 68 69 70

    The ``ComplexTensor`` is a unique type of paddle. If x is ``ComplexTensor``, then 
    ``x.real`` is the real part, and ``x.imag`` is the imaginary part.

    Args:
        data(scalar|tuple|list|ndarray|Tensor|ComplexTensor): Initial data for the tensor.
            Can be a scalar, list, tuple, numpy\.ndarray, paddle\.Tensor, paddle\.ComplexTensor.
71
        dtype(str|np.dtype, optional): The desired data type of returned tensor. Can be 'bool' , 'float16' , 
72
            'float32' , 'float64' , 'int8' , 'int16' , 'int32' , 'int64' , 'uint8'. And
73 74
            'complex64' , 'complex128' only for ComplexTensor. Default: None, infers dtype from ``data`` 
            except for python float number which gets dtype from ``get_default_type`` .
75 76 77 78 79
        place(CPUPlace|CUDAPinnedPlace|CUDAPlace, optional): The place to allocate Tensor. Can be  
            CPUPlace, CUDAPinnedPlace, CUDAPlace. Default: None, means global place.
        stop_gradient(bool, optional): Whether to block the gradient propagation of Autograd. Default: True.

    Returns:
80
        Tensor: A Tensor or ComplexTensor constructed from ``data`` .
81 82 83 84 85

    Raises:
        TypeError: If the data type of ``data`` is not scalar, list, tuple, numpy.ndarray, paddle.Tensor, paddle.ComplexTensor
        ValueError: If ``data`` is tuple|list, it can't contain nested tuple|list with different lengths , such as: [[1, 2], [3, 4, 5]]
        TypeError: If ``dtype`` is not bool, float16, float32, float64, int8, int16, int32, int64, uint8, complex64, complex128
86
        ValueError: If ``place`` is not paddle.CPUPlace, paddle.CUDAPinnedPlace, paddle.CUDAPlace
87 88 89 90 91 92 93 94 95 96 97

    Examples:

    .. code-block:: python

        import paddle
                
        type(paddle.to_tensor(1))
        # <class 'paddle.Tensor'>

        paddle.to_tensor(1)
98 99
        # Tensor(shape=[1], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
        #        [1])
100 101 102

        x = paddle.to_tensor(1)
        paddle.to_tensor(x, dtype='int32', place=paddle.CPUPlace()) # A new tensor will be constructed due to different dtype or place
103 104
        # Tensor(shape=[1], dtype=int32, place=CPUPlace, stop_gradient=True,
        #        [1])
105 106

        paddle.to_tensor((1.1, 2.2), place=paddle.CUDAPinnedPlace())
107 108
        # Tensor(shape=[1], dtype=float32, place=CUDAPinnedPlace, stop_gradient=True,
        #        [1])
109 110

        paddle.to_tensor([[0.1, 0.2], [0.3, 0.4]], place=paddle.CUDAPlace(0), stop_gradient=False)
111 112 113
        # Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=False,
        #        [[0.10000000, 0.20000000],
        #         [0.30000001, 0.40000001]])
114

115
        type(paddle.to_tensor([[1+1j, 2], [3+2j, 4]]), dtype='complex64')
116 117 118
        # <class 'paddle.ComplexTensor'>

        paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64')
119 120 121 122 123 124
        # ComplexTensor[real](shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
        #                     [[1., 2.],
        #                      [3., 4.]])
        # ComplexTensor[imag](shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
        #                     [[1., 0.],
        #                      [2., 0.]])
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
    """

    if place is None:
        place = _current_expected_place()
    elif not isinstance(place,
                        (core.CPUPlace, core.CUDAPinnedPlace, core.CUDAPlace)):
        raise ValueError(
            "'place' must be any of paddle.Place, paddle.CUDAPinnedPlace, paddle.CUDAPlace"
        )

    #Todo(zhouwei): Support allocate tensor on any other specified card
    if isinstance(place, core.CUDAPlace) and isinstance(
            _current_expected_place(), core.CUDAPlace) and place._get_device_id(
            ) != _current_expected_place()._get_device_id():
        place = _current_expected_place()

    if not isinstance(data, np.ndarray):
        if np.isscalar(data) and not isinstance(data, str):
            data = np.array([data])
        elif isinstance(data, (list, tuple)):
            data = np.array(data)
            if data.dtype == np.object:
                raise ValueError(
                    "\n\tFaild to convert input data to a regular ndarray :\n\t - Usually "
                    "this means the input data contains nested lists with different lengths. "
                )
        elif isinstance(data, paddle.Tensor):
            data.stop_gradient = stop_gradient
            if not data.place._equals(place):
                data = data._copy_to(place, False)
            if dtype:
                if convert_dtype(dtype) != convert_dtype(data.dtype):
                    return data.astype(convert_dtype(dtype))
            return data
        elif isinstance(data, paddle.ComplexTensor):
            return data
        else:
            raise TypeError(
                "Can't constructs a 'paddle.Tensor' with data type {}, data type must be scalar|list|tuple|numpy.ndarray|paddle.Tensor|paddle.ComplexTensor".
                format(type(data)))
165 166 167 168 169 170 171 172 173 174 175 176
        if not dtype and data.dtype in [
                'float16', 'float32', 'float64', 'complex64', 'complex128'
        ]:
            default_type = paddle.get_default_dtype()
            if np.iscomplexobj(data):
                default_type = 'complex64' if default_type in [
                    'float16', 'float32'
                ] else 'complex128'
            data = data.astype(default_type)

    if dtype and convert_dtype(dtype) != data.dtype:
        data = data.astype(dtype)
177 178

    if not np.iscomplexobj(data):
179
        if dtype and convert_dtype(dtype) != data.dtype:
180
            data = data.astype(dtype)
181 182 183 184
        return paddle.Tensor(
            value=data,
            place=place,
            persistable=False,
L
Leo Chen 已提交
185
            zero_copy=False,
186 187 188 189 190 191
            stop_gradient=stop_gradient)
    else:
        name = unique_name.generate('generated_tensor')
        real_tensor = paddle.Tensor(
            value=data.real,
            place=place,
L
Leo Chen 已提交
192
            zero_copy=False,
193 194 195 196 197
            name=name + ".real",
            stop_gradient=stop_gradient)
        imag_tensor = paddle.Tensor(
            value=data.imag,
            place=place,
L
Leo Chen 已提交
198
            zero_copy=False,
199 200 201 202 203
            name=name + ".imag",
            stop_gradient=stop_gradient)
        return paddle.ComplexTensor(real_tensor, imag_tensor)


204
def full_like(x, fill_value, dtype=None, name=None):
P
Pei Yang 已提交
205
    """
S
swtkiwi 已提交
206

207 208
    This function creates a tensor filled with ``fill_value`` which has identical shape of ``x`` and ``dtype``.
    If the ``dtype`` is None, the data type of Tensor is same with ``x``.
209

P
Pei Yang 已提交
210
    Args:
211 212
        x(Tensor): The input tensor which specifies shape and data type. The data type can be bool, float16, float32, float64, int32, int64.
        fill_value(bool|float|int): The value to fill the tensor with. Note: this value shouldn't exceed the range of the output data type.
W
wangchaochaohu 已提交
213
        dtype(np.dtype|str, optional): The data type of output. The data type can be one
214 215
            of bool, float16, float32, float64, int32, int64. The default value is None, which means the output 
            data type is the same as input.
216 217
        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`
    
P
Pei Yang 已提交
218
    Returns:
219
        Tensor: Tensor which is created according to ``x``, ``fill_value`` and ``dtype``.
220
    
P
Pei Yang 已提交
221 222
    Examples:
        .. code-block:: python
223

P
Pei Yang 已提交
224 225
          import paddle
          import numpy as np
226 227
          
          input = paddle.full(shape=[2, 3], fill_value=0.0, dtype='float32', name='input')
P
Pei Yang 已提交
228
          output = paddle.full_like(input, 2.0)
229 230
          # [[2. 2. 2.]
          #  [2. 2. 2.]]
P
Pei Yang 已提交
231 232 233
    """

    if dtype is None:
234
        dtype = x.dtype
235
    else:
236 237 238 239 240
        if not isinstance(dtype, core.VarDesc.VarType):
            dtype = convert_np_dtype_to_dtype_(dtype)

    if in_dygraph_mode():
        return core.ops.fill_any_like(x, 'value', fill_value, 'dtype', dtype)
P
Pei Yang 已提交
241

242
    helper = LayerHelper("full_like", **locals())
243 244 245
    check_variable_and_dtype(
        x, 'x', ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
        'full_like')
246 247
    check_dtype(dtype, 'dtype',
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
248
                'full_like/zeros_like/ones_like')
249
    out = helper.create_variable_for_type_inference(dtype=dtype)
250

P
Pei Yang 已提交
251 252
    helper.append_op(
        type='fill_any_like',
253
        inputs={'X': [x]},
254
        attrs={'value': fill_value,
255
               "dtype": dtype},
P
Pei Yang 已提交
256
        outputs={'Out': [out]})
257
    out.stop_gradient = True
P
Pei Yang 已提交
258 259 260
    return out


261
def ones(shape, dtype=None, name=None):
262
    """
S
swtkiwi 已提交
263

264 265 266
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 1.

    Args:
267
        shape(tuple|list|Tensor): Shape of the Tensor to be created, the data type of shape is int32 or int64.
W
wangchaochaohu 已提交
268
        dtype(np.dtype|str, optional): Data type of output Tensor, it supports
269 270 271
            bool, float16, float32, float64, int32 and int64. Default: if None, the data type is 'float32'.
        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`
    
272
    Returns:
273
        Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1.
274 275 276 277

    Examples:
        .. code-block:: python

278 279
          import paddle 
          
280
          # default dtype for ones OP
281 282 283 284 285 286 287 288 289
          data1 = paddle.ones(shape=[3, 2]) 
          # [[1. 1.]
          #  [1. 1.]
          #  [1. 1.]]
          
          data2 = paddle.ones(shape=[2, 2], dtype='int32') 
          # [[1 1]
          #  [1 1]]
          
290
          # shape is a Tensor
291
          shape = paddle.full(shape=[2], dtype='int32', fill_value=2)
292 293 294
          data3 = paddle.ones(shape=shape, dtype='int32') 
          # [[1 1]
          #  [1 1]]
295
    """
296 297 298
    if dtype is None:
        dtype = 'float32'
    return fill_constant(value=1.0, shape=shape, dtype=dtype, name=name)
299 300


301
def ones_like(x, dtype=None, name=None):
302
    """
303 304
    This OP returns a Tensor filled with the value 1, with the same shape and
    data type (use ``dtype`` if ``dtype`` is not None) as ``x``.
305 306

    Args:
307 308 309 310 311 312 313 314 315 316
        x(Tensor): The input tensor which specifies shape and dtype. The
            dtype of ``x`` can be bool, float16, float32, float64, int32, int64.
        dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the
            output tensor. Supported data types: bool, float16, float32, float64,
            int32, int64. If ``dtype`` is None, the data type is the same as ``x``.
            Default is None.
        name(str, optional): The default value is None. Normally there is no
            need for user to set this property. For more information, please
            refer to :ref:`api_guide_Name`.

317
    Returns:
318 319 320 321 322
        Tensor: A Tensor filled with the value 1, with the same shape and
        data type (use ``dtype`` if ``dtype`` is not None) as ``x``.

    Raise:
        TypeError: If ``dtype`` is not None and is not bool, float16, float32,
Z
zhupengyang 已提交
323
        float64, int32 or int64.
324 325 326 327

    Examples:
        .. code-block:: python

328
            import paddle
329

330
            x = paddle.to_tensor([1,2,3])
Z
zhupengyang 已提交
331 332
            out1 = paddle.ones_like(x) # [1., 1., 1.]
            out2 = paddle.ones_like(x, dtype='int32') # [1, 1, 1]
333

334 335
    """
    return full_like(x=x, fill_value=1, dtype=dtype, name=name)
336 337


338
def zeros(shape, dtype=None, name=None):
339 340 341 342
    """
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0.

    Args:
343
        shape(tuple|list|Tensor): Shape of the Tensor to be created, the data type of ``shape`` is int32 or int64.
W
wangchaochaohu 已提交
344
        dtype(np.dtype|str, optional): Data type of output Tensor, it supports
345 346 347
            bool, float16, float32, float64, int32 and int64. Default: if None, the date type is float32.
        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`.
348 349

    Returns:
350
        Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0.
351 352 353 354 355

    Examples:
        .. code-block:: python

          import paddle
356
          
357 358 359 360 361 362 363 364 365
          data = paddle.zeros(shape=[3, 2], dtype='float32') 
          # [[0. 0.]
          #  [0. 0.]
          #  [0. 0.]]
          data = paddle.zeros(shape=[2, 2]) 
          # [[0. 0.]
          #  [0. 0.]]
          
          # shape is a Tensor
366
          shape = paddle.full(shape=[2], dtype='int32', fill_value=2)
367
          data3 = paddle.zeros(shape=shape, dtype='int32') 
368 369
          # [[0 0]
          #  [0 0]]
370
    """
371 372 373
    if dtype is None:
        dtype = 'float32'
    return fill_constant(value=0.0, shape=shape, dtype=dtype, name=name)
374 375


376
def zeros_like(x, dtype=None, name=None):
377
    """
378 379
    This OP returns a Tensor filled with the value 0, with the same shape and
    data type (use ``dtype`` if ``dtype`` is not None) as ``x``.
380 381

    Args:
382 383 384 385 386 387
        x(Tensor): The input tensor which specifies shape and dtype. The
            dtype of ``x`` can be bool, float16, float32, float64, int32, int64.
        dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the
            output tensor. Supported data types: bool, float16, float32, float64,
            int32, int64. If ``dtype`` is None, the data type is the same as ``x``.
            Default is None.
388 389 390
        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`.
391 392

    Returns:
393 394
        Tensor: A Tensor filled with the value 0, with the same shape and
        data type (use ``dtype`` if ``dtype`` is not None) as ``x``.
395

396
    Raise:
397
        TypeError: If ``dtype`` is not None and is not bool, float16, float32,
Z
zhupengyang 已提交
398
        float64, int32 or int64.
399

400 401 402
    Examples:
        .. code-block:: python

403
            import paddle
404

Z
zhupengyang 已提交
405
            x = paddle.to_tensor([1, 2, 3])
406 407
            out1 = paddle.zeros_like(x) # [0., 0., 0.]
            out2 = paddle.zeros_like(x, dtype='int32') # [0, 0, 0]
408

409 410
    """
    return full_like(x=x, fill_value=0, dtype=dtype, name=name)
411 412


413
def eye(num_rows, num_columns=None, dtype=None, name=None):
414
    """
415
    
416
    This function constructs 2-D Tensor with ones on the diagonal and zeros elsewhere.
417

418
    Args:
419 420
        num_rows(int): the number of rows in each batch Tensor.
        num_columns(int, optional): the number of columns in each batch Tensor.
421
            If None, default: num_rows.
W
wangchaochaohu 已提交
422
        dtype(np.dtype|str, optional): The data type of the returned Tensor.
423 424
            It should be int32, int64, float16, float32, float64. Default: if None, the data type
            is float32.
425 426
        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`
427

428
    Returns:
429
        Tensor: An identity Tensor or LoDTensor of shape [num_rows, num_columns].
430

431 432
    Examples:
        .. code-block:: python
433
          
434
          import paddle
435

436
          data = paddle.eye(3, dtype='int32')
437 438 439
          # [[1 0 0]
          #  [0 1 0]
          #  [0 0 1]]
440
          data = paddle.eye(2, 3, dtype='int32')
441 442
          # [[1 0 0]
          #  [0 1 0]]
443 444
    """

445 446 447
    if dtype is None:
        dtype = 'float32'
    if num_columns is None:
448
        num_columns = num_rows
449 450 451 452 453
    return paddle.fluid.layers.eye(num_rows=num_rows,
                                   num_columns=num_columns,
                                   batch_shape=None,
                                   dtype=dtype,
                                   name=name)
454 455


456
def full(shape, fill_value, dtype=None, name=None):
W
wangchaochaohu 已提交
457
    """
S
swtkiwi 已提交
458

459
    This Op return a Tensor with the ``fill_value`` which size is same as ``shape``.
W
wangchaochaohu 已提交
460 461
    
    Args:
462
        shape(list|tuple|Tensor): Shape of the Tensor to be created.
W
wangchaochaohu 已提交
463 464
                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].
465 466 467
                If ``shape`` is an Tensor, it should be an 1-D Tensor .
        fill_value(bool|float|int|Tensor): The constant value
            used to initialize the Tensor to be created. If ``fill_value`` is an Tensor, it must be an 1-D Tensor.
W
wangchaochaohu 已提交
468
        dtype(np.dtype|str, optional): Data type of the output Tensor
W
wangchaochaohu 已提交
469
            which can be float16, float32, float64, int32, int64, if dytpe is `None`, the data
470
            type of created Tensor is `float32`
W
wangchaochaohu 已提交
471 472 473
        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`.
    
474
    Returns:
475
        Tensor: Tensor which is created according to ``shape``, ``fill_value`` and ``dtype``.
476

W
wangchaochaohu 已提交
477 478 479
    Examples:
        .. code-block:: python

480
          import paddle
W
wangchaochaohu 已提交
481

482 483 484
          data1 = paddle.full(shape=[2,1], fill_value=0, dtype='int64') 
          #[[0]
          # [0]]
W
wangchaochaohu 已提交
485

486
          # attr shape is a list which contains Tensor.
487
          positive_2 = paddle.full([1], 2, "int32")
488 489
          data3 = paddle.full(shape=[1, positive_2], dtype='float32', fill_value=1.5)
          # [[1.5 1.5]]
W
wangchaochaohu 已提交
490

491
          # attr shape is a Tensor.
492
          shape = paddle.full([2], 2, "int32")
493 494 495
          data4 = paddle.full(shape=shape, dtype='bool', fill_value=True) 
          # [[True True] 
          #  [True True]]
496
          
497
          # attr fill_value is a Tensor.
498
          val = paddle.full([1], 2.0, "float32")
499 500 501
          data5 = paddle.full(shape=[2,1], fill_value=val, dtype='float32')
          # [[2.0] 
          #  [2.0]]
W
wangchaochaohu 已提交
502 503 504 505 506
    """

    if dtype is None:
        dtype = 'float32'

507
    return fill_constant(shape=shape, dtype=dtype, value=fill_value, name=name)
508 509


510
def arange(start=0, end=None, step=1, dtype=None, name=None):
511
    """
512
    This OP returns a 1-D Tensor with spaced values within a given interval.
513

514 515
    Values are generated into the half-open interval [``start``, ``end``) with
    the ``step``. (the interval including ``start`` but excluding ``end``).
516

517 518
    If ``dtype`` is float32 or float64, we advise adding a small epsilon to
    ``end`` to avoid floating point rounding errors when comparing against ``end``.
519 520

    Parameters:
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
        start(float|int|Tensor): Start of interval. The interval includes this
            value. If ``end`` is None, the half-open interval is [0, ``start``).
            If ``start`` is a Tensor, it is a 1-D Tensor with shape [1], with
            data type int32, int64, float32, float64. Default is 0.
        end(float|int|Tensor, optional): End of interval. The interval does not
            include this value. If ``end`` is a Tensor, it is a 1-D Tensor with
            shape [1], with data type int32, int64, float32, float64. If ``end``
            is None, the half-open interval is [0, ``start``). Default is None.
        step(float|int|Tensor, optional): Spacing between values. For any out,
            it is the istance between two adjacent values, out[i+1] - out[i].
            If ``step`` is a Tensor, it is a 1-D Tensor with shape [1], with
            data type int32, int64, float32, float64. Default is 1.
        dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the
            output tensor. Supported data types: int32, int64, float32, float64.
            If ``dytpe`` is None, the data type is float32. Default is None.
        name(str, optional): The default value is None. Normally there is no
            need for user to set this property. For more information, please
            refer to :ref:`api_guide_Name`.
539

540 541
    Returns: 
        Tensor: A 1-D Tensor with values from the interval [``start``, ``end``)
Z
zhupengyang 已提交
542 543
        taken with common difference ``step`` beginning from ``start``. Its
        data type is set by ``dtype``.
544

545
    Raises:
546
        TypeError: If ``dtype`` is not int32, int64, float32, float64.
547

Z
zhupengyang 已提交
548
    Examples:
549 550
        .. code-block:: python

Z
zhupengyang 已提交
551
            import paddle
552

Z
zhupengyang 已提交
553 554
            out1 = paddle.arange(5)
            # [0, 1, 2, 3, 4]
555

Z
zhupengyang 已提交
556 557
            out2 = paddle.arange(3, 9, 2.0)
            # [3, 5, 7]
558

Z
zhupengyang 已提交
559 560 561
            # use 4.999 instead of 5.0 to avoid floating point rounding errors
            out3 = paddle.arange(4.999, dtype='float32')
            # [0., 1., 2., 3., 4.]
562

Z
zhupengyang 已提交
563 564 565
            start_var = paddle.to_tensor([3])
            out4 = paddle.arange(start_var, 7)
            # [3, 4, 5, 6]
566 567 568 569 570 571 572
             
    """
    if dtype is None:
        dtype = 'int64'
    if end is None:
        end = start
        start = 0
573

574
    return paddle.fluid.layers.range(start, end, step, dtype, name)
W
WuHaobo 已提交
575 576 577 578 579 580


def _tril_triu_op(helper):
    """Base op of tril_op and triu_op
    """
    op_type = helper.layer_type
Y
yaoxuefeng 已提交
581
    x = helper.kwargs.get('x', None)
W
WuHaobo 已提交
582 583 584 585 586

    assert x is not None, 'x cannot be None in {}'.format(op_type)
    check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
                             op_type)
    if len(x.shape) < 2:
Y
yaoxuefeng 已提交
587
        raise ValueError("x shape in {} must be at least 2-D".format(op_type))
W
WuHaobo 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
    diagonal = helper.kwargs.get('diagonal', 0)
    if not isinstance(diagonal, (int, )):
        raise TypeError("diagonal in {} must be a python Int".format(op_type))
    name = helper.kwargs.get('name', None)

    if name is None:
        out = helper.create_variable_for_type_inference(dtype=x.dtype)
    else:
        out = helper.create_variable(
            name=name, dtype=x.dtype, persistable=False)

    helper.append_op(
        type="tril_triu",
        inputs={"X": x},
        attrs={
            "diagonal": diagonal,
            "lower": True if op_type == 'tril' else False,
        },
        outputs={"Out": out}, )

    return out


Y
yaoxuefeng 已提交
611
def tril(x, diagonal=0, name=None):
W
WuHaobo 已提交
612
    """
613 614
	:alias_main: paddle.tril
	:alias: paddle.tril,paddle.tensor.tril,paddle.tensor.creation.tril
S
swtkiwi 已提交
615

W
WuHaobo 已提交
616
    This op returns the lower triangular part of a matrix (2-D tensor) or batch
Y
yaoxuefeng 已提交
617
    of matrices :attr:`x`, the other elements of the result tensor are set 
W
WuHaobo 已提交
618 619 620 621
    to 0. The lower triangular part of the matrix is defined as the elements 
    on and below the diagonal.

    Args:
Y
yaoxuefeng 已提交
622
        x (Variable): The input variable x which is a Tensor.
W
WuHaobo 已提交
623 624 625 626 627 628 629 630 631 632 633 634
            Support data types: ``float64``, ``float32``, ``int32``, ``int64``.
        diagonal (int, optional): The diagonal to consider, default value is 0.
            If :attr:`diagonal` = 0, all elements on and below the main diagonal are
            retained. A positive value includes just as many diagonals above the main
            diagonal, and similarly a negative value excludes just as many diagonals below
            the main diagonal. The main diagonal are the set of indices
            :math:`\{(i, i)\}` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where
            :math:`d_{1}, d_{2}` are the dimensions of the matrix.
        name (str, optional): The default value is None. Normally there is no need for
            user to set this property. For more information, please refer to :ref:`api_guide_Name`.

    Returns:
Y
yaoxuefeng 已提交
635 636
        Variable: Tensor, results of lower triangular operation by the specified diagonal of input tensor x,
        it's data type is the same as x's Tensor.
W
WuHaobo 已提交
637 638 639

    Raises:
        TypeError: diagonal is not a int type.
Y
yaoxuefeng 已提交
640
        ValueError: dimension of :attr:`x` is less than 2.
W
WuHaobo 已提交
641 642 643 644 645

    Examples:
        .. code-block:: python

            import numpy as np
Y
yaoxuefeng 已提交
646
            import paddle
W
WuHaobo 已提交
647 648 649 650 651 652

            data = np.arange(1, 13, dtype="int64").reshape(3,-1)
            # array([[ 1,  2,  3,  4],
            #        [ 5,  6,  7,  8],
            #        [ 9, 10, 11, 12]])

653
            paddle.disable_static()
Y
yaoxuefeng 已提交
654

655
            x = paddle.to_tensor(data)
Y
yaoxuefeng 已提交
656 657
            
            tril1 = paddle.tensor.tril(x)
W
WuHaobo 已提交
658 659 660 661 662
            # array([[ 1,  0,  0,  0],
            #        [ 5,  6,  0,  0],
            #        [ 9, 10, 11,  0]])

            # example 2, positive diagonal value
Y
yaoxuefeng 已提交
663
            tril2 = paddle.tensor.tril(x, diagonal=2)
W
WuHaobo 已提交
664 665 666 667 668
            # array([[ 1,  2,  3,  0], 
            #        [ 5,  6,  7,  8],
            #        [ 9, 10, 11, 12]])

            # example 3, negative diagonal value
Y
yaoxuefeng 已提交
669
            tril3 = paddle.tensor.tril(x, diagonal=-1)
W
WuHaobo 已提交
670 671 672 673
            # array([[ 0,  0,  0,  0],
            #        [ 5,  0,  0,  0],
            #        [ 9, 10,  0,  0]])

674 675 676
    """
    if in_dygraph_mode():
        op = getattr(core.ops, 'tril_triu')
Y
yaoxuefeng 已提交
677
        return op(x, 'diagonal', diagonal, "lower", True)
W
WuHaobo 已提交
678 679 680 681

    return _tril_triu_op(LayerHelper('tril', **locals()))


Y
yaoxuefeng 已提交
682
def triu(x, diagonal=0, name=None):
W
WuHaobo 已提交
683
    """
684 685
	:alias_main: paddle.triu
	:alias: paddle.triu,paddle.tensor.triu,paddle.tensor.creation.triu
S
swtkiwi 已提交
686

W
WuHaobo 已提交
687
    This op returns the upper triangular part of a matrix (2-D tensor) or batch of matrices
Y
yaoxuefeng 已提交
688
    :attr:`x`, the other elements of the result tensor are set to 0.
W
WuHaobo 已提交
689 690 691 692
    The upper triangular part of the matrix is defined as the elements on and
    above the diagonal.

    Args:
Y
yaoxuefeng 已提交
693
        x (Variable): The input variable x which is a Tensor.
W
WuHaobo 已提交
694 695 696 697 698 699 700 701 702 703 704 705
            Support data types: ``float64``, ``float32``, ``int32``, ``int64``.
        diagonal (int, optional): The diagonal to consider, default value is 0.
            If :attr:`diagonal` = 0, all elements on and above the main diagonal are
            retained. A positive value excludes just as many diagonals above the main
            diagonal, and similarly a negative value includes just as many diagonals below
            the main diagonal. The main diagonal are the set of indices
            :math:`\{(i, i)\}` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where
            :math:`d_{1}, d_{2}` are the dimensions of the matrix.
        name (str, optional): The default value is None. Normally there is no need for
            user to set this property. For more information, please refer to :ref:`api_guide_Name`.

    Returns:
Y
yaoxuefeng 已提交
706 707
        Variable: Tensor, results of upper triangular operation by the specified diagonal of input tensor x,
        it's data type is the same as x's Tensor.
W
WuHaobo 已提交
708 709 710

    Raises:
        TypeError: diagonal is not a int type.
Y
yaoxuefeng 已提交
711
        ValueError: dimension of :attr:`x` is less than 2.
W
WuHaobo 已提交
712 713 714 715 716

    Examples:
        .. code-block:: python

            import numpy as np
Y
yaoxuefeng 已提交
717
            import paddle
W
WuHaobo 已提交
718 719 720 721 722

            data = np.arange(1, 13, dtype="int64").reshape(3,-1)
            # array([[ 1,  2,  3,  4],
            #        [ 5,  6,  7,  8],
            #        [ 9, 10, 11, 12]])
Y
yaoxuefeng 已提交
723

724
            paddle.disable_static()
W
WuHaobo 已提交
725 726

            # example 1, default diagonal
727
            x = paddle.to_tensor(data)
Y
yaoxuefeng 已提交
728
            triu1 = paddle.tensor.triu(x)
W
WuHaobo 已提交
729 730 731 732 733
            # array([[ 1,  2,  3,  4],
            #        [ 0,  6,  7,  8],
            #        [ 0,  0, 11, 12]])

            # example 2, positive diagonal value
Y
yaoxuefeng 已提交
734
            triu2 = paddle.tensor.triu(x, diagonal=2)
W
WuHaobo 已提交
735 736 737 738 739
            # array([[0, 0, 3, 4],
            #        [0, 0, 0, 8],
            #        [0, 0, 0, 0]])

            # example 3, negative diagonal value
Y
yaoxuefeng 已提交
740
            triu3 = paddle.tensor.triu(x, diagonal=-1)
W
WuHaobo 已提交
741 742 743 744 745
            # array([[ 1,  2,  3,  4],
            #        [ 5,  6,  7,  8],
            #        [ 0, 10, 11, 12]])

    """
746 747
    if in_dygraph_mode():
        op = getattr(core.ops, 'tril_triu')
Y
yaoxuefeng 已提交
748
        return op(x, 'diagonal', diagonal, "lower", False)
W
WuHaobo 已提交
749 750

    return _tril_triu_op(LayerHelper('triu', **locals()))
S
suytingwan 已提交
751 752


753
def meshgrid(*args, **kwargs):
S
suytingwan 已提交
754
    """
755 756
	:alias_main: paddle.meshgrid
	:alias: paddle.meshgrid,paddle.tensor.meshgrid,paddle.tensor.creation.meshgrid
S
swtkiwi 已提交
757

758
    This op takes a list of N tensors as input *args, each of which is 1-dimensional 
S
suytingwan 已提交
759 760 761
    vector, and creates N-dimensional grids.
    
    Args:
Y
yaoxuefeng 已提交
762
        *args(Tensor|list of Tensor) : tensors (tuple(list) of tensor): the shapes of input k tensors are (N1,), 
S
suytingwan 已提交
763
            (N2,),..., (Nk,). Support data types: ``float64``, ``float32``, ``int32``, ``int64``.
764 765
        **kwargs (optional): Currently, we only accept name in **kwargs 
            The default value is None. Normally there is no need for
S
suytingwan 已提交
766 767 768
            user to set this property. For more information, please refer to :ref:`api_guide_Name`.
 
    Returns:
Y
yaoxuefeng 已提交
769
         Tensor: k tensors. The shape of each tensor is (N1, N2, ..., Nk)
S
suytingwan 已提交
770 771 772 773 774 775

    Examples:
      .. code-block:: python

          import paddle

Y
yaoxuefeng 已提交
776 777 778 779
          x = paddle.randint(low=0, high=100, shape=[100])
          y = paddle.randint(low=0, high=100, shape=[200])

          grid_x, grid_y = paddle.meshgrid(x, y)
S
suytingwan 已提交
780

Y
yaoxuefeng 已提交
781 782
          print(grid_x.shape)
          print(grid_y.shape)
S
suytingwan 已提交
783 784 785 786 787 788

          #the shape of res_1 is (100, 200)
          #the shape of res_2 is (100, 200)

    """

789 790
    if len(args) == 1 and isinstance(args[0], (list, tuple)):
        args = args[0]
S
suytingwan 已提交
791
    if in_dygraph_mode():
792 793
        num = len(args)
        out = core.ops.meshgrid(list(args), num)
S
suytingwan 已提交
794 795
        return out

796
    name = kwargs.get("name", None)
S
suytingwan 已提交
797 798
    helper = LayerHelper('meshgrid', **locals())

799 800
    if not isinstance(args, (list, tuple)):
        raise TypeError("The type of input args in meshgrid should be list.")
S
suytingwan 已提交
801

802
    for id, input_ in enumerate(args):
S
suytingwan 已提交
803 804 805 806
        check_dtype(input_.dtype, 'create data type',
                    ['float16', 'float32', 'float64', 'int32', 'int64'],
                    'meshgrid')

807
    num = len(args)
S
suytingwan 已提交
808
    out = [
809
        helper.create_variable_for_type_inference(dtype=args[i].dtype)
S
suytingwan 已提交
810 811
        for i in range(num)
    ]
812 813
    helper.append_op(
        type='meshgrid', inputs={'X': list(args)}, outputs={'Out': out})
S
suytingwan 已提交
814 815

    return out
816 817 818 819 820 821 822 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 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891


def diag(x, offset=0, padding_value=0, name=None):
    """
    If ``x`` is a vector (1-D tensor), a 2-D square tensor whth the elements of ``x`` as the diagonal is returned.

    If ``x`` is a matrix (2-D tensor), a 1-D tensor with the diagonal elements of ``x`` is returned.

    The argument ``offset`` controls the diagonal offset:

    If ``offset`` = 0, it is the main diagonal.

    If ``offset`` > 0, it is superdiagonal.

    If ``offset`` < 0, it is subdiagonal.

    Args:
        x (Tensor): The input tensor. Its shape is either 1-D or 2-D. Its data type should be float32, float64, int32, int64.
        offset (int, optional): The diagonal offset. A positive value represents superdiagonal, 0 represents the main diagonal, and a negative value represents subdiagonal.
        padding_value (int|float, optional): Use this value to fill the area outside the specified diagonal band. Only takes effect when the input is a 1-D Tensor. The default value is 0.
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

    Returns:
        Tensor, a square matrix or a vector. The output data type is the same as input data type.

    Examples:
        .. code-block:: python

          import paddle

          paddle.disable_static()
          x = paddle.to_tensor([1, 2, 3])
          y = paddle.diag(x)
          print(y.numpy())
          # [[1 0 0]
          #  [0 2 0]
          #  [0 0 3]]

          y = paddle.diag(x, offset=1)
          print(y.numpy())
          # [[0 1 0 0]
          #  [0 0 2 0]
          #  [0 0 0 3]
          #  [0 0 0 0]]

          y = paddle.diag(x, padding_value=6)
          print(y.numpy())
          # [[1 6 6]
          #  [6 2 6]
          #  [6 6 3]]

        .. code-block:: python

          import paddle

          paddle.disable_static()
          x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])
          y = paddle.diag(x)
          print(y.numpy())
          # [1 5]

          y = paddle.diag(x, offset=1)
          print(y.numpy())
          # [2 6]

          y = paddle.diag(x, offset=-1)
          print(y.numpy())
          # [4]
    """
    if in_dygraph_mode():
        return core.ops.diag_v2(x, "offset", offset, "padding_value",
                                padding_value)

    check_type(x, 'x', (Variable), 'diag_v2')
    check_dtype(x.dtype, 'x', ['float32', 'float64', 'int32', 'int64'],
                'diag_v2')
892 893 894 895 896 897 898
    check_type(offset, 'offset', (int), 'diag_v2')
    check_type(padding_value, 'padding_value', (int, float), 'diag_v2')
    if len(x.shape) != 1 and len(x.shape) != 2:
        raise ValueError(
            "The dimension of input x must be either 1 or 2, but received {}".
            format(len(x.shape)))

899 900 901 902 903 904 905 906 907 908 909 910 911
    helper = LayerHelper("diag_v2", **locals())

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

    helper.append_op(
        type='diag_v2',
        inputs={'X': x},
        outputs={'Out': out},
        attrs={'offset': offset,
               'padding_value': padding_value})

    out.stop_gradient = True
    return out
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 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


def empty(shape, dtype=None, name=None):
    """
    This Op returns a Tensor with uninitialized data which size is same as ``shape``.
    
    Args:
        shape(list|tuple|Tensor): Shape of the Tensor to be created.
                The data type of dimension of shape 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 Tensor, it should be an 1-D Tensor.
        dtype(np.dtype|str, optional): Data type of the output Tensor
            which can be bool, float16, float32, float64, int32, int64, if dytpe is `None`, the data
            type of created Tensor use global default dtype (see ``get_default_dtype``
            for details).
        name(str, optional): The default value is None. Normally there is no need for user to set this
            property. For more information, please refer to :ref:`api_guide_Name`.
    
    Returns:
        Tensor: Tensor which is created according to ``shape`` and ``dtype``, and is uninitialized.

    Examples:
        .. code-block:: python

          import paddle
          import numpy as np

          paddle.set_device("cpu")  # and use cpu device

          # example 1: argument ``shape`` is a list which doesn't contain Tensor.
          data1 = paddle.empty(shape=[2,3], dtype='float32')
          #[[4.3612203e+27 1.8176809e+31 1.3555911e-19]     # uninitialized
          # [1.1699684e-19 1.3563156e-19 3.6408321e-11]]    # uninitialized

          # example 2: argument ``shape`` is a Tensor, the data type must be int64 or int32.
          shape_data = np.array([2, 3]).astype('int32')
          shape = paddle.to_tensor(shape_data)
          data2 = paddle.empty(shape=shape, dtype='float32')
          #[[1.7192326e-37 4.8125365e-38 1.9866003e-36]     # uninitialized
          # [1.3284029e-40 7.1117408e-37 2.5353012e+30]]    # uninitialized

          # example 3: argument ``shape`` is a list which contains Tensor.
          dim2_data = np.array([3]).astype('int32')
          dim2 = paddle.to_tensor(dim2_data)
          data3 = paddle.empty(shape=[2, dim2], dtype='float32')
          #[[1.1024214e+24 7.0379409e+22 6.5737699e-34]     # uninitialized
          # [7.5563101e+31 7.7130405e+31 2.8020654e+20]]    # uninitialized
    """

    if dtype is None:
        dtype = paddle.get_default_dtype()

    dtype = convert_dtype(dtype)

    if in_dygraph_mode():
        shape = utils.convert_shape_to_list(shape)
        out = core.ops.empty('shape', shape, 'dtype',
                             convert_np_dtype_to_dtype_(dtype))
        out.stop_gradient = True
        return out

    helper = LayerHelper("empty", **locals())
    inputs = {}

    check_dtype(dtype, 'dtype',
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'empty')
    check_type(shape, 'shape', (Variable, list, tuple), 'empty')

    if isinstance(shape, Variable):
        check_dtype(shape.dtype, 'shape', ['int32', 'int64'], 'empty')

    attrs = {}
    utils.get_shape_tensor_inputs(
        inputs=inputs, attrs=attrs, shape=shape, op_type='empty')

    out = helper.create_variable_for_type_inference(dtype=dtype)
    attrs['dtype'] = convert_np_dtype_to_dtype_(dtype)
    helper.append_op(
        type='empty',
        inputs=inputs,
        outputs={'Out': [out]},
        attrs=attrs,
        stop_gradient=True)
    out.stop_gradient = True
    return out
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063


def empty_like(x, dtype=None, name=None):
    """
    This Op returns a Tensor with uninitialized data which has identical shape of ``x`` and ``dtype``.
    If the ``dtype`` is None, the data type of Tensor is same with ``x``.
    
    Args:
        x(Tensor): The input tensor which specifies shape and data type. The data type can be bool, float16, float32, float64, int32, int64.
        dtype(np.dtype|str, optional): The data type of output. The data type can be one
            of bool, float16, float32, float64, int32, int64. The default value is None, which means the output 
            data type is the same as input.
        name(str, optional): The default value is None. Normally there is no need for user to set this
            property. For more information, please refer to :ref:`api_guide_Name`.
    
    Returns:
        Tensor: Tensor which is created according to ``x`` and ``dtype``, and is uninitialized.

    Examples:
        .. code-block:: python

          import paddle
          import numpy as np

          paddle.set_device("cpu")  # and use cpu device

          x = paddle.randn([2, 3], 'float32')
          output = paddle.empty_like(x)
          #[[1.8491974e+20 1.8037303e+28 1.7443726e+28]     # uninitialized
          # [4.9640171e+28 3.0186127e+32 5.6715899e-11]]    # uninitialized
    """

    if dtype is None:
        dtype = x.dtype
    dtype = convert_dtype(dtype)

    if in_dygraph_mode():
        out = core.ops.empty('shape', x.shape, 'dtype',
                             convert_np_dtype_to_dtype_(dtype))
        out.stop_gradient = True
        return out

    helper = LayerHelper("empty_like", **locals())
    check_variable_and_dtype(
        x, 'x', ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
        'empty_like')
    check_dtype(dtype, 'dtype',
                ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
                'empty_like')
    out = helper.create_variable_for_type_inference(dtype=dtype)

    inputs = {}
    attrs = {}
    attrs['dtype'] = convert_np_dtype_to_dtype_(dtype)
    shape = paddle.shape(x)
    utils.get_shape_tensor_inputs(
        inputs=inputs, attrs=attrs, shape=shape, op_type='empty_like')

    helper.append_op(
        type='empty',
        inputs=inputs,
        outputs={'Out': [out]},
        attrs=attrs,
        stop_gradient=True)
    out.stop_gradient = True
    return out
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 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 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137


def assign(x, output=None):
    """
 
 
    The OP copies the :attr:`x` to the :attr:`output`.
 
    Parameters:
        x (Tensor|numpy.ndarray): A tensor or numpy ndarray, its data type supports
            float16, float32, float64, int32 and int64.
        output (Tensor, optional): A tensor. If :attr:`output` is None, a new tensor will
            be created as :attr:`output`. Default: None.
 
    Returns:
        Tensor: A tensor with the same shape, data type and value as :attr:`x`.
 
    Examples:
        .. code-block:: python
 
          import paddle
          import numpy as np
          data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') # [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
          array = np.array([[1, 1],
                            [3, 4],
                            [1, 3]]).astype(np.int64)
          result1 = paddle.zeros(shape=[3, 3], dtype='float32')
          paddle.assign(array, result1) # result1 = [[1, 1], [3 4], [1, 3]]
          result2 = paddle.assign(data)  # result2 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
          result3 = paddle.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]]
    """
    helper = LayerHelper('assign', **locals())
    check_type(x, 'x', (Variable, numpy.ndarray), 'assign')
    if isinstance(x, Variable):
        check_dtype(
            x.dtype, 'x',
            ['float16', 'float32', 'float64', 'int32', 'int64', 'bool'],
            'assign', '(When the type of input in assign is Variable.)')
        if output is None:
            output = helper.create_variable_for_type_inference(dtype=x.dtype)
        helper.append_op(
            type='assign', inputs={'X': [x]}, outputs={'Out': [output]})
    elif isinstance(x, numpy.ndarray):
        dtype = convert_np_dtype_to_dtype_(x.dtype)
        if dtype == VarDesc.VarType.BOOL:
            value_name = "bool_values"
            values = [bool(v) for v in x.flat]
        elif dtype == VarDesc.VarType.FP32:
            value_name = "fp32_values"
            values = [float(v) for v in x.flat]
        elif dtype == VarDesc.VarType.INT32:
            value_name = "int32_values"
            values = [int(v) for v in x.flat]
        elif dtype == VarDesc.VarType.INT64:
            value_name = "int64_values"
            values = [int(v) for v in x.flat]
        else:
            raise TypeError(
                "When the type of 'x' in assign is numpy.ndarray, "
                "the data type of 'x' must be bool, float32, int32 or int64, but "
                "received %s." % convert_dtype(dtype))
        if x.size > 1024 * 1024:
            raise ValueError("The size of input is too big. Please consider "
                             "saving it to file and 'load_op' to load it")
        if output is None:
            output = helper.create_variable_for_type_inference(dtype=x.dtype)
        helper.append_op(
            type='assign_value',
            outputs={'Out': [output]},
            attrs={'dtype': dtype,
                   'shape': list(x.shape),
                   value_name: values})

    return output