creation.py 65.4 KB
Newer Older
1
#   Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14
#
# 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
import numpy as np
17
import math
18 19
from paddle.common_ops_import import fill_constant
from ..fluid.layers import utils
Z
zhiboniu 已提交
20 21 22 23
from ..static import Variable, device_guard
from ..framework import _current_expected_place, _get_paddle_place
from ..framework import dygraph_only
from ..framework import core
24 25
from ..framework import in_dygraph_mode, _non_static_mode
from ..framework import LayerHelper
P
Pei Yang 已提交
26
from ..fluid.data_feeder import check_variable_and_dtype, check_type, check_dtype, convert_dtype
Z
zhiboniu 已提交
27
from ..framework import convert_np_dtype_to_dtype_, _varbase_creator, OpProtoHolder
28
# TODO: define functions to get create a tensor  
29
import paddle
W
wanghuancoder 已提交
30
from paddle import _C_ops
31 32
from ..fluid.framework import _in_legacy_dygraph, _in_eager_without_dygraph_check
import warnings
33

34 35
__all__ = []

W
wangchaochaohu 已提交
36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
def _complex_to_real_dtype(dtype):
    if dtype == core.VarDesc.VarType.COMPLEX64:
        return core.VarDesc.VarType.FP32
    elif dtype == core.VarDesc.VarType.COMPLEX128:
        return core.VarDesc.VarType.FP64
    else:
        return dtype


def _real_to_complex_dtype(dtype):
    if dtype == core.VarDesc.VarType.FP32:
        return core.VarDesc.VarType.COMPLEX64
    elif dtype == core.VarDesc.VarType.FP64:
        return core.VarDesc.VarType.COMPLEX128
    else:
        return dtype


def linspace(start, stop, num, dtype=None, name=None):
    r"""
    This OP return fixed number of evenly spaced values within a given interval.

    Args:
        start(int|float|Tensor): The input :attr:`start` is start variable of range. It is a scalar, \
            or a Tensor of shape [1] with input data type int32, int64, float32 or float64.
        stop(int|float|Tensor): The input :attr:`stop` is start variable of range. It is a scalar, \
            or a Tensor of shape [1] with input data type int32, int64, float32 or float64.
        num(int|Tensor): The input :attr:`num` is given num of the sequence. It is an int scalar, \
            or a Tensor of shape [1] with data type int32.
        dtype(np.dtype|str, optional): The data type of output tensor, it could be
            int32, int64, float32 and float64. Default: if None, the data type is float32.
        name(str, optional): Normally there is no need for user to set this property. 
            For more information, please refer to :ref:`api_guide_Name`.Default: None.

    Returns:
        Tensor: 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`. 

    Examples:
        .. code-block:: python

             import paddle
             data = paddle.linspace(0, 10, 5, 'float32') # [0.0,  2.5,  5.0,  7.5, 10.0]
             data = paddle.linspace(0, 10, 1, 'float32') # [0.0]

    """
    if dtype is None:
        dtype = 'float32'
    tensor_num = num
    tensor_start = start
    tensor_stop = stop
    if not isinstance(num, Variable):
        check_type(num, 'num', (int), 'linspace')
    if not isinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)
    if not isinstance(start, Variable):
        with device_guard("cpu"):
95
            tensor_start = fill_constant([1], dtype, start, force_cpu=True)
96 97
    if not isinstance(stop, Variable):
        with device_guard("cpu"):
98
            tensor_stop = fill_constant([1], dtype, stop, force_cpu=True)
99 100
    if not isinstance(num, Variable):
        with device_guard("cpu"):
101
            tensor_num = fill_constant([1], 'int32', num, force_cpu=True)
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
    if _non_static_mode():
        return _C_ops.linspace(tensor_start, tensor_stop, tensor_num, 'dtype',
                               dtype)

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

    start_dtype = convert_dtype(tensor_start.dtype)
    stop_dtype = convert_dtype(tensor_stop.dtype)
    out_dtype = convert_dtype(dtype)
    if isinstance(start, Variable):
        check_dtype(start.dtype, 'start',
                    ['float32', 'float64', 'int32', 'int64'], 'linspace')
    else:
        check_type(start, 'start', (int, float), 'linspace')

    if isinstance(stop, Variable):
        check_dtype(stop.dtype, 'stop',
                    ['float32', 'float64', 'int32', 'int64'], 'linspace')
    else:
        check_type(stop, 'stop', (int, float), 'linspace')
    if isinstance(num, Variable):
        check_dtype(num.dtype, 'num', ['int32'], 'linspace')
    check_dtype(dtype, 'dtype', ['int32', 'int64', 'float32', 'float64'],
                'linspace')
    if ((stop_dtype == "float64" or start_dtype == "float64") and
            out_dtype in ["float32", "int32"]) or ((stop_dtype == "int64" or
                                                    start_dtype == "int64") and
                                                   out_dtype == "int32"):
        raise ValueError(
            "The dtype of start/stop is {}/{} but the attr(dtype) of linspace is {}, "
            "which may cause data type overflows. Please reset attr(dtype) of linspace."
            .format(start_dtype, stop_dtype, dtype))

    out = helper.create_variable_for_type_inference(dtype=dtype)

    helper.append_op(
        type='linspace',
        inputs={'Start': tensor_start,
                'Stop': tensor_stop,
                'Num': tensor_num},
        attrs={'dtype': dtype},
        outputs={'Out': [out]})
    if isinstance(num, int):
        out.desc.set_shape((num, ))
    return out


149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
def logspace(start, stop, num, base=10.0, dtype=None, name=None):
    r"""
    Return fixed number of logarithmical-evenly spaced values within the interval \
    :math:`[base^{start}, base^{stop}]`.
    
    Notes:
        This API does not compute the gradient.
    
    Args:
        start(int|float|Tensor): The input :attr:`start` is exponent of first entry in \
            the sequence. It is a scalar, or a Tensor of shape [1] with input data \
            type int32, int64, float32 or float64.
        stop(int|float|Tensor): The input :attr:`stop` is exponent of last entry in the \
            sequence. It is a scalar, or a Tensor of shape [1] with input data \
            type int32, int64, float32 or float64.
        num(int|Tensor): The input :attr:`num` is given number of items in the sequence. \
            It is an int scalar, or a Tensor of shape [1] with data type int32.
        base(int|float|Tensor): The input :attr:`base` is base of the logarithm function. \
            It is a scalar, or a Tensor of shape [1] with input data type int32, int64, \
            float32 or float64.
        dtype(np.dtype|str, optional): The data type of output tensor, it could be \
            int32, int64, float32 or float64. Default: if None, the data type is float32. \
        name(str, optional): Normally there is no need for user to set this property. \
            For more information, please refer to :ref:`api_guide_Name`. Default: None.

    Returns:
        Tensor: The output data type will be float32, float64. The 1-D tensor with \
        fixed number of logarithmical-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 exponential of :attr:`start` with base :attr:`base`. 

    Examples:
        .. code-block:: python
            :name: logspace-example

            import paddle
            data = paddle.logspace(0, 10, 5, 2, 'float32')
            # [1.          , 5.65685415  , 32.         , 181.01933289, 1024.       ]
            data = paddle.logspace(0, 10, 1, 2, 'float32')
            # [1.]
    """
    if dtype is None:
        dtype = 'float32'
    tensor_num = num
    tensor_start = start
    tensor_stop = stop
    tensor_base = base
    if not isinstance(num, Variable):
        check_type(num, 'num', (int), 'logspace')
    if not isinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)
    if not isinstance(start, Variable):
        with device_guard("cpu"):
            tensor_start = fill_constant([1], dtype, start)
    if not isinstance(stop, Variable):
        with device_guard("cpu"):
            tensor_stop = fill_constant([1], dtype, stop)
    if not isinstance(num, Variable):
        with device_guard("cpu"):
            tensor_num = fill_constant([1], 'int32', num)
    if not isinstance(base, Variable):
        with device_guard("cpu"):
            tensor_base = fill_constant([1], dtype, base)
    if _non_static_mode():
        return _C_ops.logspace(tensor_start, tensor_stop, tensor_num,
                               tensor_base, 'dtype', dtype)

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

    start_dtype = convert_dtype(tensor_start.dtype)
    stop_dtype = convert_dtype(tensor_stop.dtype)
    base_dtype = convert_dtype(tensor_base.dtype)
    out_dtype = convert_dtype(dtype)
    if isinstance(start, Variable):
        check_dtype(start.dtype, 'start',
                    ['float32', 'float64', 'int32', 'int64'], 'logspace')
    else:
        check_type(start, 'start', (int, float), 'logspace')

    if isinstance(stop, Variable):
        check_dtype(stop.dtype, 'stop',
                    ['float32', 'float64', 'int32', 'int64'], 'logspace')
    else:
        check_type(stop, 'stop', (int, float), 'logspace')

    if isinstance(num, Variable):
        check_dtype(num.dtype, 'num', ['int32'], 'logspace')

    if isinstance(base, Variable):
        check_dtype(base.dtype, 'base',
                    ['float32', 'float64', 'int32', 'int64'], 'logspace')
    else:
        check_type(base, 'base', (int, float), 'logspace')

    check_dtype(dtype, 'dtype', ['int32', 'int64', 'float32', 'float64'],
                'logspace')
    if ((stop_dtype == "float64" or start_dtype == "float64"
                                 or base_dtype == "float64")
                                 and out_dtype in ["float32", "int32"]) or \
       ((stop_dtype == "int64" or start_dtype == "int64"
                               or base_dtype == "int64")
                               and out_dtype == "int32"):
        raise ValueError(
            "The dtype of start/stop/base is {}/{}/{} but the attr(dtype) of logspace is {}, "
            "which may cause data type overflows. Please reset attr(dtype) of logspace."
            .format(start_dtype, stop_dtype, base_dtype, dtype))

    out = helper.create_variable_for_type_inference(dtype=dtype)

    helper.append_op(
        type='logspace',
        inputs={
            'Start': tensor_start,
            'Stop': tensor_stop,
            'Num': tensor_num,
            'Base': tensor_base
        },
        attrs={'dtype': dtype},
        outputs={'Out': [out]})
    if isinstance(num, int):
        out.desc.set_shape((num, ))
    return out


273 274
@dygraph_only
def to_tensor(data, dtype=None, place=None, stop_gradient=True):
275
    r"""
C
chentianyu03 已提交
276 277
    Constructs a ``paddle.Tensor`` from ``data`` , 
    which can be scalar, tuple, list, numpy\.ndarray, paddle\.Tensor.
278

279 280
    If the ``data`` is already a Tensor, copy will be performed and return a new tensor.
    If you only want to change stop_gradient property, please call ``Tensor.stop_gradient = stop_gradient`` directly.
281 282

    Args:
C
chentianyu03 已提交
283 284
        data(scalar|tuple|list|ndarray|Tensor): Initial data for the tensor.
            Can be a scalar, list, tuple, numpy\.ndarray, paddle\.Tensor.
285
        dtype(str|np.dtype, optional): The desired data type of returned tensor. Can be 'bool' , 'float16' , 
C
chentianyu03 已提交
286 287
            'float32' , 'float64' , 'int8' , 'int16' , 'int32' , 'int64' , 'uint8',
            'complex64' , 'complex128'. Default: None, infers dtype from ``data`` 
288
            except for python float number which gets dtype from ``get_default_type`` .
289 290 291
        place(CPUPlace|CUDAPinnedPlace|CUDAPlace|str, optional): The place to allocate Tensor. Can be  
            CPUPlace, CUDAPinnedPlace, CUDAPlace. Default: None, means global place. If ``place`` is 
            string, It can be ``cpu``, ``gpu:x`` and ``gpu_pinned``, where ``x`` is the index of the GPUs. 
292 293 294
        stop_gradient(bool, optional): Whether to block the gradient propagation of Autograd. Default: True.

    Returns:
C
chentianyu03 已提交
295
        Tensor: A Tensor constructed from ``data`` .
296 297 298 299 300 301 302 303 304 305 306

    Examples:

    .. code-block:: python

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

        paddle.to_tensor(1)
307
        # Tensor(shape=[1], dtype=int64, place=CPUPlace, stop_gradient=True,
308
        #        [1])
309

310 311 312
        x = paddle.to_tensor(1, stop_gradient=False)
        print(x)
        # Tensor(shape=[1], dtype=int64, place=CPUPlace, stop_gradient=False,
313
        #        [1])
314

315 316 317
        paddle.to_tensor(x)  # A new tensor will be created with default stop_gradient=True
        # Tensor(shape=[1], dtype=int64, place=CPUPlace, stop_gradient=True,
        #        [1])        
318

319 320
        paddle.to_tensor([[0.1, 0.2], [0.3, 0.4]], place=paddle.CPUPlace(), stop_gradient=False)
        # Tensor(shape=[2, 2], dtype=float32, place=CPUPlace, stop_gradient=False,
321 322
        #        [[0.10000000, 0.20000000],
        #         [0.30000001, 0.40000001]])
323

C
chentianyu03 已提交
324
        type(paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64'))
325
        # <class 'paddle.Tensor'>
326 327

        paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64')
328
        # Tensor(shape=[2, 2], dtype=complex64, place=CPUPlace, stop_gradient=True,
C
chentianyu03 已提交
329 330
        #        [[(1+1j), (2+0j)],
        #         [(3+2j), (4+0j)]])
331
    """
332
    place = _get_paddle_place(place)
333 334
    if place is None:
        place = _current_expected_place()
335
    elif not isinstance(place, (core.Place, core.CPUPlace, core.CUDAPinnedPlace,
336
                                core.CUDAPlace, core.NPUPlace, core.XPUPlace,
F
fwenguang 已提交
337
                                core.MLUPlace, core.CustomPlace)):
338
        raise ValueError(
F
fwenguang 已提交
339
            "'place' must be any of paddle.Place, paddle.CPUPlace, paddle.CUDAPinnedPlace, paddle.CUDAPlace, paddle.NPUPlace, paddle.XPUPlace, paddle.MLUPlace, paddle.CustomPlace"
340 341 342
        )

    if not isinstance(data, np.ndarray):
343

344
        def _handle_dtype(data, dtype):
345 346 347 348 349
            if dtype:
                if convert_dtype(dtype) != convert_dtype(data.dtype):
                    return data.astype(convert_dtype(dtype))
            return data

350 351 352 353 354 355 356 357 358
        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. "
                )
W
wanghuancoder 已提交
359 360 361 362 363 364
        elif isinstance(data, paddle.Tensor) and not in_dygraph_mode():
            data = data._copy_to(place, False)
            data = _handle_dtype(data, dtype)
            data.stop_gradient = stop_gradient
            return data
        elif isinstance(data, core.eager.Tensor) and in_dygraph_mode():
365
            data = data._copy_to(place, False)
366
            data = _handle_dtype(data, dtype)
367
            data.stop_gradient = stop_gradient
368
            return data
369
        elif isinstance(data, (core.LoDTensor, core.Tensor)):
370
            # should't expose it to users, just for internal use.
371 372
            # convert core.Tensor/core.LoDTensor to VarBase first
            # Currenly, there is no copy when places are same
W
wanghuancoder 已提交
373 374 375 376
            if in_dygraph_mode():
                data = core.eager.Tensor(data)
            else:
                data = paddle.Tensor(data)
377 378 379 380
            if not data.place._equals(place):
                data = data._copy_to(place, False)
            data = _handle_dtype(data, dtype)
            data.stop_gradient = stop_gradient
381
            return data
382 383
        else:
            raise TypeError(
384
                "Can't constructs a 'paddle.Tensor' with data type {}, data type must be scalar|list|tuple|np.ndarray|paddle.Tensor".
385
                format(type(data)))
386 387 388 389 390 391 392 393 394 395 396 397 398 399
        if not dtype:
            if 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)
            # Windows default type is 'int32', while Linux/Mac is 'int64'. Unify they.
            if data.dtype in ['int32']:
                default_type = "int64"
                data = data.astype(default_type)
400 401

    if dtype and convert_dtype(dtype) != data.dtype:
402
        data = data.astype(convert_dtype(dtype))
403

J
Jiabin Yang 已提交
404 405 406 407 408 409 410 411
    if _in_eager_without_dygraph_check() and isinstance(data, np.ndarray):
        return core.eager.Tensor(
            value=data,
            place=place,
            persistable=False,
            zero_copy=False,
            name=None,
            stop_gradient=stop_gradient)
412 413 414 415 416 417 418
    else:
        return paddle.Tensor(
            value=data,
            place=place,
            persistable=False,
            zero_copy=False,
            stop_gradient=stop_gradient)
419 420


421
def full_like(x, fill_value, dtype=None, name=None):
P
Pei Yang 已提交
422
    """
S
swtkiwi 已提交
423

424 425
    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``.
426

P
Pei Yang 已提交
427
    Args:
428 429
        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 已提交
430
        dtype(np.dtype|str, optional): The data type of output. The data type can be one
431 432
            of bool, float16, float32, float64, int32, int64. The default value is None, which means the output 
            data type is the same as input.
433 434
        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 已提交
435
    Returns:
436
        Tensor: Tensor which is created according to ``x``, ``fill_value`` and ``dtype``.
437
    
P
Pei Yang 已提交
438 439
    Examples:
        .. code-block:: python
440

P
Pei Yang 已提交
441 442
          import paddle
          import numpy as np
443 444
          
          input = paddle.full(shape=[2, 3], fill_value=0.0, dtype='float32', name='input')
P
Pei Yang 已提交
445
          output = paddle.full_like(input, 2.0)
446 447
          # [[2. 2. 2.]
          #  [2. 2. 2.]]
P
Pei Yang 已提交
448 449 450
    """

    if dtype is None:
451
        dtype = x.dtype
452
    else:
453 454 455
        if not isinstance(dtype, core.VarDesc.VarType):
            dtype = convert_np_dtype_to_dtype_(dtype)

456 457 458 459
    if in_dygraph_mode():
        return _C_ops.final_state_full_like(x, fill_value, dtype, x.place)

    if _in_legacy_dygraph():
W
wanghuancoder 已提交
460
        return _C_ops.fill_any_like(x, 'value', fill_value, 'dtype', dtype)
P
Pei Yang 已提交
461

462
    helper = LayerHelper("full_like", **locals())
463
    check_variable_and_dtype(
464 465
        x, 'x',
        ['bool', 'float16', 'float32', 'float64', 'int16', 'int32', 'int64'],
466
        'full_like')
467 468 469 470
    check_dtype(
        dtype, 'dtype',
        ['bool', 'float16', 'float32', 'float64', 'int16', 'int32', 'int64'],
        'full_like/zeros_like/ones_like')
471
    out = helper.create_variable_for_type_inference(dtype=dtype)
472

P
Pei Yang 已提交
473 474
    helper.append_op(
        type='fill_any_like',
475
        inputs={'X': [x]},
476
        attrs={'value': fill_value,
477
               "dtype": dtype},
P
Pei Yang 已提交
478
        outputs={'Out': [out]})
479
    out.stop_gradient = True
P
Pei Yang 已提交
480 481 482
    return out


483
def ones(shape, dtype=None, name=None):
484
    """
S
swtkiwi 已提交
485

486 487 488
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 1.

    Args:
489
        shape(tuple|list|Tensor): Shape of the Tensor to be created, the data type of shape is int32 or int64.
W
wangchaochaohu 已提交
490
        dtype(np.dtype|str, optional): Data type of output Tensor, it supports
491 492 493
            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`
    
494
    Returns:
495
        Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1.
496 497 498 499

    Examples:
        .. code-block:: python

500 501
          import paddle 
          
502
          # default dtype for ones OP
503 504 505 506 507 508 509 510 511
          data1 = paddle.ones(shape=[3, 2]) 
          # [[1. 1.]
          #  [1. 1.]
          #  [1. 1.]]
          
          data2 = paddle.ones(shape=[2, 2], dtype='int32') 
          # [[1 1]
          #  [1 1]]
          
512
          # shape is a Tensor
513
          shape = paddle.full(shape=[2], dtype='int32', fill_value=2)
514 515 516
          data3 = paddle.ones(shape=shape, dtype='int32') 
          # [[1 1]
          #  [1 1]]
517
    """
518 519 520
    if dtype is None:
        dtype = 'float32'
    return fill_constant(value=1.0, shape=shape, dtype=dtype, name=name)
521 522


523
def ones_like(x, dtype=None, name=None):
524
    """
525 526
    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``.
527 528

    Args:
529 530
        x(Tensor): The input tensor which specifies shape and dtype. The
            dtype of ``x`` can be bool, float16, float32, float64, int32, int64.
531
        dtype(str|np.dtype, optional): The data type of the
532 533 534 535 536 537 538
            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`.

539
    Returns:
540 541 542 543 544
        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 已提交
545
        float64, int32 or int64.
546 547 548 549

    Examples:
        .. code-block:: python

550
            import paddle
551

552
            x = paddle.to_tensor([1,2,3])
Z
zhupengyang 已提交
553 554
            out1 = paddle.ones_like(x) # [1., 1., 1.]
            out2 = paddle.ones_like(x, dtype='int32') # [1, 1, 1]
555

556 557
    """
    return full_like(x=x, fill_value=1, dtype=dtype, name=name)
558 559


560
def zeros(shape, dtype=None, name=None):
561 562 563 564
    """
    The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0.

    Args:
565
        shape(tuple|list|Tensor): Shape of the Tensor to be created, the data type of ``shape`` is int32 or int64.
W
wangchaochaohu 已提交
566
        dtype(np.dtype|str, optional): Data type of output Tensor, it supports
567 568 569
            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`.
570 571

    Returns:
572
        Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0.
573 574 575 576 577

    Examples:
        .. code-block:: python

          import paddle
578
          
579 580 581 582 583 584 585 586 587
          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
588
          shape = paddle.full(shape=[2], dtype='int32', fill_value=2)
589
          data3 = paddle.zeros(shape=shape, dtype='int32') 
590 591
          # [[0 0]
          #  [0 0]]
592
    """
593 594 595
    if dtype is None:
        dtype = 'float32'
    return fill_constant(value=0.0, shape=shape, dtype=dtype, name=name)
596 597


598
def zeros_like(x, dtype=None, name=None):
599
    """
600 601
    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``.
602 603

    Args:
604 605
        x(Tensor): The input tensor which specifies shape and dtype. The
            dtype of ``x`` can be bool, float16, float32, float64, int32, int64.
606
        dtype(str|np.dtype, optional): The data type of the
607 608 609
            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.
610 611 612
        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`.
613 614

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

618
    Raise:
619
        TypeError: If ``dtype`` is not None and is not bool, float16, float32,
Z
zhupengyang 已提交
620
        float64, int32 or int64.
621

622 623 624
    Examples:
        .. code-block:: python

625
            import paddle
626

Z
zhupengyang 已提交
627
            x = paddle.to_tensor([1, 2, 3])
628 629
            out1 = paddle.zeros_like(x) # [0., 0., 0.]
            out2 = paddle.zeros_like(x, dtype='int32') # [0, 0, 0]
630

631 632
    """
    return full_like(x=x, fill_value=0, dtype=dtype, name=name)
633 634


635
def eye(num_rows, num_columns=None, dtype=None, name=None):
636
    """
637
    
638
    This function constructs 2-D Tensor with ones on the diagonal and zeros elsewhere.
639

640
    Args:
641 642
        num_rows(int): the number of rows in each batch Tensor.
        num_columns(int, optional): the number of columns in each batch Tensor.
643
            If None, default: num_rows.
W
wangchaochaohu 已提交
644
        dtype(np.dtype|str, optional): The data type of the returned Tensor.
645 646
            It should be int32, int64, float16, float32, float64. Default: if None, the data type
            is float32.
647 648
        name(str, optional): The default value is None.  Normally there is no need for 
            user to set this property.  For more information, please refer to :ref:`api_guide_Name`
649

650
    Returns:
651
        Tensor: An identity Tensor or LoDTensor of shape [num_rows, num_columns].
652

653 654
    Examples:
        .. code-block:: python
655
          
656
          import paddle
657

658
          data = paddle.eye(3, dtype='int32')
659 660 661
          # [[1 0 0]
          #  [0 1 0]
          #  [0 0 1]]
662
          data = paddle.eye(2, 3, dtype='int32')
663 664
          # [[1 0 0]
          #  [0 1 0]]
665 666
    """

667 668 669
    if dtype is None:
        dtype = 'float32'
    if num_columns is None:
670
        num_columns = num_rows
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703

    if not isinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)
    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

    if _non_static_mode():
        out = _C_ops.eye('dtype', dtype, 'num_rows', num_rows, 'num_columns',
                         num_columns)

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

    out.stop_gradient = True
    return out
704 705


706
def full(shape, fill_value, dtype=None, name=None):
W
wangchaochaohu 已提交
707
    """
S
swtkiwi 已提交
708

709
    This Op return a Tensor with the ``fill_value`` which size is same as ``shape``.
W
wangchaochaohu 已提交
710 711
    
    Args:
712
        shape(list|tuple|Tensor): Shape of the Tensor to be created.
W
wangchaochaohu 已提交
713 714
                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].
715 716 717
                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 已提交
718
        dtype(np.dtype|str, optional): Data type of the output Tensor
W
wangchaochaohu 已提交
719
            which can be float16, float32, float64, int32, int64, if dytpe is `None`, the data
720
            type of created Tensor is `float32`
W
wangchaochaohu 已提交
721 722 723
        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`.
    
724
    Returns:
725
        Tensor: Tensor which is created according to ``shape``, ``fill_value`` and ``dtype``.
726

W
wangchaochaohu 已提交
727 728 729
    Examples:
        .. code-block:: python

730
          import paddle
W
wangchaochaohu 已提交
731

732 733 734
          data1 = paddle.full(shape=[2,1], fill_value=0, dtype='int64') 
          #[[0]
          # [0]]
W
wangchaochaohu 已提交
735

736
          # attr shape is a list which contains Tensor.
737
          positive_2 = paddle.full([1], 2, "int32")
738 739
          data3 = paddle.full(shape=[1, positive_2], dtype='float32', fill_value=1.5)
          # [[1.5 1.5]]
W
wangchaochaohu 已提交
740

741
          # attr shape is a Tensor.
742
          shape = paddle.full([2], 2, "int32")
743 744 745
          data4 = paddle.full(shape=shape, dtype='bool', fill_value=True) 
          # [[True True] 
          #  [True True]]
746
          
747
          # attr fill_value is a Tensor.
748
          val = paddle.full([1], 2.0, "float32")
749 750 751
          data5 = paddle.full(shape=[2,1], fill_value=val, dtype='float32')
          # [[2.0] 
          #  [2.0]]
W
wangchaochaohu 已提交
752 753 754 755 756
    """

    if dtype is None:
        dtype = 'float32'

757
    return fill_constant(shape=shape, dtype=dtype, value=fill_value, name=name)
758 759


760
def arange(start=0, end=None, step=1, dtype=None, name=None):
761
    """
762
    Returns a 1-D Tensor with spaced values within a given interval.
763

764 765
    Values are generated into the half-open interval [``start``, ``end``) with
    the ``step``. (the interval including ``start`` but excluding ``end``).
766

767 768
    If ``dtype`` is float32 or float64, we advise adding a small epsilon to
    ``end`` to avoid floating point rounding errors when comparing against ``end``.
769 770

    Parameters:
771 772 773 774 775 776 777 778 779 780 781 782
        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.
783
        dtype(str|np.dtype, optional): The data type of the
784 785
            output tensor. Supported data types: int32, int64, float32, float64.
            If ``dytpe`` is None, the data type is float32. Default is None.
786
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
787

788 789
    Returns: 
        Tensor: A 1-D Tensor with values from the interval [``start``, ``end``)
Z
zhupengyang 已提交
790 791
        taken with common difference ``step`` beginning from ``start``. Its
        data type is set by ``dtype``.
792

Z
zhupengyang 已提交
793
    Examples:
794 795
        .. code-block:: python

Z
zhupengyang 已提交
796
            import paddle
797

Z
zhupengyang 已提交
798 799
            out1 = paddle.arange(5)
            # [0, 1, 2, 3, 4]
800

Z
zhupengyang 已提交
801 802
            out2 = paddle.arange(3, 9, 2.0)
            # [3, 5, 7]
803

Z
zhupengyang 已提交
804 805 806
            # 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.]
807

Z
zhupengyang 已提交
808 809 810
            start_var = paddle.to_tensor([3])
            out4 = paddle.arange(start_var, 7)
            # [3, 4, 5, 6]
811 812 813 814 815 816 817
             
    """
    if dtype is None:
        dtype = 'int64'
    if end is None:
        end = start
        start = 0
818

819 820 821 822 823
    out_shape = None
    if not isinstance(start, Variable) and not isinstance(
            end, Variable) and not isinstance(step, Variable):
        out_shape = [int(math.ceil((end - start) / step))]

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
    if not isinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)

    if not isinstance(start, Variable):
        with device_guard("cpu"):
            start = fill_constant([1], dtype, start, force_cpu=True)
    elif start.dtype != dtype:
        start = paddle.cast(start, dtype)

    if not isinstance(end, Variable):
        with device_guard("cpu"):
            end = fill_constant([1], dtype, end, force_cpu=True)
    elif end.dtype != dtype:
        end = paddle.cast(end, dtype)

    if not isinstance(step, Variable):
        with device_guard("cpu"):
            step = fill_constant([1], dtype, step, force_cpu=True)
    elif step.dtype != dtype:
        step = paddle.cast(step, dtype)

    if in_dygraph_mode():
        return _C_ops.final_state_arange(start, end, step, dtype,
                                         _current_expected_place())

    if _in_legacy_dygraph():
        out = _C_ops.range(start, end, step)
        out.stop_gradient = True
        return out

    check_dtype(dtype, 'dtype', ['float32', 'float64', 'int32', 'int64'],
                'range/arange')
    helper = LayerHelper('range', **locals())
    out = helper.create_variable_for_type_inference(dtype, shape=out_shape)
    helper.append_op(
        type='range',
        inputs={'Start': start,
                'End': end,
                'Step': step},
        outputs={'Out': out})
    out.stop_gradient = True
865 866
    if out_shape is not None:
        out.desc.set_shape(out_shape)
867
    return out
W
WuHaobo 已提交
868 869 870 871 872 873


def _tril_triu_op(helper):
    """Base op of tril_op and triu_op
    """
    op_type = helper.layer_type
Y
yaoxuefeng 已提交
874
    x = helper.kwargs.get('x', None)
W
WuHaobo 已提交
875 876

    assert x is not None, 'x cannot be None in {}'.format(op_type)
877 878
    check_variable_and_dtype(
        x, 'x', ['float16', 'float32', 'float64', 'int32', 'int64'], op_type)
W
WuHaobo 已提交
879
    if len(x.shape) < 2:
Y
yaoxuefeng 已提交
880
        raise ValueError("x shape in {} must be at least 2-D".format(op_type))
W
WuHaobo 已提交
881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
    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 已提交
904
def tril(x, diagonal=0, name=None):
905
    r"""
906
    Returns the lower triangular part of a matrix (2-D tensor) or batch
Y
yaoxuefeng 已提交
907
    of matrices :attr:`x`, the other elements of the result tensor are set 
W
WuHaobo 已提交
908 909 910 911
    to 0. The lower triangular part of the matrix is defined as the elements 
    on and below the diagonal.

    Args:
Y
yaoxuefeng 已提交
912
        x (Tensor): The input x which is a Tensor.
L
liuyuhui 已提交
913
            Support data types: ``bool``, ``float64``, ``float32``, ``int32``, ``int64``.
W
WuHaobo 已提交
914 915 916 917 918 919 920
        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.
921
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
W
WuHaobo 已提交
922 923

    Returns:
Y
yaoxuefeng 已提交
924
        Tensor: Results of lower triangular operation by the specified diagonal of input tensor x,
Y
yaoxuefeng 已提交
925
        it's data type is the same as x's Tensor.
W
WuHaobo 已提交
926 927 928 929

    Examples:
        .. code-block:: python

Y
yaoxuefeng 已提交
930
            import paddle
W
WuHaobo 已提交
931

932 933 934 935 936
            data = paddle.arange(1, 13, dtype="int64").reshape([3,-1])
            # Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True,
            #        [[1 , 2 , 3 , 4 ],
            #         [5 , 6 , 7 , 8 ],
            #         [9 , 10, 11, 12]])
Y
yaoxuefeng 已提交
937

938 939 940 941 942
            tril1 = paddle.tril(data)
            # Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True,
            #        [[1 , 0 , 0 , 0 ],
            #         [5 , 6 , 0 , 0 ],
            #         [9 , 10, 11, 0 ]])
W
WuHaobo 已提交
943 944

            # example 2, positive diagonal value
945 946 947 948 949
            tril2 = paddle.tril(data, diagonal=2)
            # Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True,
            #        [[1 , 2 , 3 , 0 ],
            #         [5 , 6 , 7 , 8 ],
            #         [9 , 10, 11, 12]])
W
WuHaobo 已提交
950 951

            # example 3, negative diagonal value
952 953 954 955 956
            tril3 = paddle.tril(data, diagonal=-1)
            # Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True,
            #        [[0 , 0 , 0 , 0 ],
            #         [5 , 0 , 0 , 0 ],
            #         [9 , 10, 0 , 0 ]])
957
    """
F
From00 已提交
958 959 960 961
    if in_dygraph_mode():
        return _C_ops.final_state_tril_triu(x, diagonal, True)

    if _in_legacy_dygraph():
W
wanghuancoder 已提交
962
        op = getattr(_C_ops, 'tril_triu')
Y
yaoxuefeng 已提交
963
        return op(x, 'diagonal', diagonal, "lower", True)
W
WuHaobo 已提交
964 965 966 967

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


Y
yaoxuefeng 已提交
968
def triu(x, diagonal=0, name=None):
969
    r"""
W
WuHaobo 已提交
970
    This op returns the upper triangular part of a matrix (2-D tensor) or batch of matrices
Y
yaoxuefeng 已提交
971
    :attr:`x`, the other elements of the result tensor are set to 0.
W
WuHaobo 已提交
972 973 974 975
    The upper triangular part of the matrix is defined as the elements on and
    above the diagonal.

    Args:
Y
yaoxuefeng 已提交
976
        x (Tensor): The input x which is a Tensor.
W
WuHaobo 已提交
977 978 979 980 981 982 983 984 985 986 987 988
            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 已提交
989
        Tensor: Results of upper triangular operation by the specified diagonal of input tensor x,
Y
yaoxuefeng 已提交
990
        it's data type is the same as x's Tensor.
W
WuHaobo 已提交
991 992 993

    Raises:
        TypeError: diagonal is not a int type.
Y
yaoxuefeng 已提交
994
        ValueError: dimension of :attr:`x` is less than 2.
W
WuHaobo 已提交
995 996 997 998 999

    Examples:
        .. code-block:: python

            import numpy as np
Y
yaoxuefeng 已提交
1000
            import paddle
W
WuHaobo 已提交
1001 1002 1003 1004 1005

            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 已提交
1006

W
WuHaobo 已提交
1007 1008

            # example 1, default diagonal
1009
            x = paddle.to_tensor(data)
Y
yaoxuefeng 已提交
1010
            triu1 = paddle.tensor.triu(x)
W
WuHaobo 已提交
1011 1012 1013 1014 1015
            # array([[ 1,  2,  3,  4],
            #        [ 0,  6,  7,  8],
            #        [ 0,  0, 11, 12]])

            # example 2, positive diagonal value
Y
yaoxuefeng 已提交
1016
            triu2 = paddle.tensor.triu(x, diagonal=2)
W
WuHaobo 已提交
1017 1018 1019 1020 1021
            # array([[0, 0, 3, 4],
            #        [0, 0, 0, 8],
            #        [0, 0, 0, 0]])

            # example 3, negative diagonal value
Y
yaoxuefeng 已提交
1022
            triu3 = paddle.tensor.triu(x, diagonal=-1)
W
WuHaobo 已提交
1023 1024 1025 1026 1027
            # array([[ 1,  2,  3,  4],
            #        [ 5,  6,  7,  8],
            #        [ 0, 10, 11, 12]])

    """
F
From00 已提交
1028 1029 1030 1031
    if in_dygraph_mode():
        return _C_ops.final_state_tril_triu(x, diagonal, False)

    if _in_legacy_dygraph():
W
wanghuancoder 已提交
1032
        op = getattr(_C_ops, 'tril_triu')
Y
yaoxuefeng 已提交
1033
        return op(x, 'diagonal', diagonal, "lower", False)
W
WuHaobo 已提交
1034 1035

    return _tril_triu_op(LayerHelper('triu', **locals()))
S
suytingwan 已提交
1036 1037


1038
def meshgrid(*args, **kwargs):
S
suytingwan 已提交
1039
    """
1040
    This op takes a list of N tensors as input *args, each of which is 1-dimensional 
S
suytingwan 已提交
1041 1042 1043
    vector, and creates N-dimensional grids.
    
    Args:
Y
yaoxuefeng 已提交
1044
        *args(Tensor|list of Tensor) : tensors (tuple(list) of tensor): the shapes of input k tensors are (N1,), 
S
suytingwan 已提交
1045
            (N2,),..., (Nk,). Support data types: ``float64``, ``float32``, ``int32``, ``int64``.
1046 1047
        **kwargs (optional): Currently, we only accept name in **kwargs 
            The default value is None. Normally there is no need for
S
suytingwan 已提交
1048 1049 1050
            user to set this property. For more information, please refer to :ref:`api_guide_Name`.
 
    Returns:
Y
yaoxuefeng 已提交
1051
         Tensor: k tensors. The shape of each tensor is (N1, N2, ..., Nk)
S
suytingwan 已提交
1052 1053 1054 1055 1056 1057

    Examples:
      .. code-block:: python

          import paddle

Y
yaoxuefeng 已提交
1058 1059 1060 1061
          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 已提交
1062

Y
yaoxuefeng 已提交
1063 1064
          print(grid_x.shape)
          print(grid_y.shape)
S
suytingwan 已提交
1065 1066 1067 1068 1069 1070

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

    """

1071 1072
    if len(args) == 1 and isinstance(args[0], (list, tuple)):
        args = args[0]
Y
YuanRisheng 已提交
1073
    if _in_legacy_dygraph():
1074
        num = len(args)
W
wanghuancoder 已提交
1075
        out = _C_ops.meshgrid(list(args), num)
S
suytingwan 已提交
1076
        return out
Y
YuanRisheng 已提交
1077 1078
    if in_dygraph_mode():
        return _C_ops.final_state_meshgrid(list(args))
S
suytingwan 已提交
1079

1080
    name = kwargs.get("name", None)
S
suytingwan 已提交
1081 1082
    helper = LayerHelper('meshgrid', **locals())

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

1086
    for id, input_ in enumerate(args):
S
suytingwan 已提交
1087 1088 1089 1090
        check_dtype(input_.dtype, 'create data type',
                    ['float16', 'float32', 'float64', 'int32', 'int64'],
                    'meshgrid')

1091
    num = len(args)
S
suytingwan 已提交
1092
    out = [
1093
        helper.create_variable_for_type_inference(dtype=args[i].dtype)
S
suytingwan 已提交
1094 1095
        for i in range(num)
    ]
1096 1097
    helper.append_op(
        type='meshgrid', inputs={'X': list(args)}, outputs={'Out': out})
S
suytingwan 已提交
1098 1099

    return out
1100 1101


L
Li Min 已提交
1102 1103
def diagflat(x, offset=0, name=None):
    """
1104
    If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned.
L
Li Min 已提交
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 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

    If ``x`` is a tensor (more than 1-D), a 2-D square tensor with the elements of flattened ``x`` as the diagonal 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. It can be any shape. 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. Default: 0 (main diagonal).
        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. The output data type is the same as input data type.

    Examples:
        .. code-block:: python

          import paddle

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

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

          y = paddle.diagflat(x, offset=-1)
          print(y.numpy())
          # [[0 0 0 0]
          #  [1 0 0 0]
          #  [0 2 0 0]
          #  [0 0 3 0]]
        
        .. code-block:: python

          import paddle

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

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

          y = paddle.diagflat(x, offset=-1)
          print(y.numpy())
          # [[0 0 0 0 0]
          #  [1 0 0 0 0]
          #  [0 2 0 0 0]
          #  [0 0 3 0 0]
          #  [0 0 0 4 0]]
    """
    padding_value = 0
Z
zhiboniu 已提交
1180
    if paddle.in_dynamic_mode():
L
Li Min 已提交
1181
        if len(x.shape) == 1:
W
wanghuancoder 已提交
1182 1183
            return _C_ops.diag_v2(x, "offset", offset, "padding_value",
                                  padding_value)
L
Li Min 已提交
1184
        else:
W
wanghuancoder 已提交
1185 1186 1187 1188
            y, _ = _C_ops.flatten_contiguous_range(x, "start_axis", 0,
                                                   "stop_axis", -1)
            return _C_ops.diag_v2(y, "offset", offset, "padding_value",
                                  padding_value)
L
Li Min 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226

    check_type(x, 'x', (Variable), 'diagflat')
    check_dtype(x.dtype, 'x', ['float32', 'float64', 'int32', 'int64'],
                'diagflat')
    check_type(offset, 'offset', (int), 'diagflat')

    helper = LayerHelper("diagflat", **locals())
    out1 = helper.create_variable_for_type_inference(dtype=x.dtype)
    out1_shape = helper.create_variable_for_type_inference(x.dtype)
    out2 = helper.create_variable_for_type_inference(dtype=x.dtype)

    if len(x.shape) == 1:
        helper.append_op(
            type='diag_v2',
            inputs={'X': x},
            outputs={'Out': out2},
            attrs={'offset': offset,
                   'padding_value': padding_value})
    else:
        helper.append_op(
            type='flatten_contiguous_range',
            inputs={'X': x},
            outputs={'Out': out1,
                     'XShape': out1_shape},
            attrs={'start_axis': 0,
                   'stop_axis': -1})
        out1.stop_gradient = True

        helper.append_op(
            type='diag_v2',
            inputs={'X': out1},
            outputs={'Out': out2},
            attrs={'offset': offset,
                   'padding_value': padding_value})
    out2.stop_gradient = True
    return out2


1227 1228
def diag(x, offset=0, padding_value=0, name=None):
    """
1229
    If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned.
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293

    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]
    """
J
Jiabin Yang 已提交
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
    if in_dygraph_mode():
        return _C_ops.final_state_diag(x, offset, padding_value)
    else:
        if _in_legacy_dygraph():
            return _C_ops.diag_v2(x, "offset", offset, "padding_value",
                                  padding_value)
        else:
            check_type(x, 'x', (Variable), 'diag_v2')
            check_dtype(x.dtype, 'x', ['float32', 'float64', 'int32', 'int64'],
                        'diag_v2')
            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)))
1310

J
Jiabin Yang 已提交
1311
            helper = LayerHelper("diag_v2", **locals())
1312

J
Jiabin Yang 已提交
1313
            out = helper.create_variable_for_type_inference(dtype=x.dtype)
1314

J
Jiabin Yang 已提交
1315 1316 1317 1318 1319 1320
            helper.append_op(
                type='diag_v2',
                inputs={'X': x},
                outputs={'Out': out},
                attrs={'offset': offset,
                       'padding_value': padding_value})
1321

J
Jiabin Yang 已提交
1322 1323
            out.stop_gradient = True
            return out
1324 1325 1326 1327


def empty(shape, dtype=None, name=None):
    """
1328
    Returns a Tensor with uninitialized data which size is same as ``shape``.
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
    
    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

1348
            import paddle
1349

1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
            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')
            print(data1)
            # Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
            #        [[0.00000000, 0.        , 0.00000000],
            #         [0.        , 0.29652897, 0.09356152]])       # uninitialized

            # example 2: argument ``shape`` is a Tensor, the data type must be int64 or int32.
            shape_data = paddle.to_tensor([2, 3]).astype('int32')
            data2 = paddle.empty(shape=shape_data, dtype='float32')
            print(data2)
            # Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
            #        [[-0.50543123, -0.09872390, -0.92634487],
            #         [-0.51007903, -0.02454148,  1.29315734]])    # uninitialized

            # example 3: argument ``shape`` is a list which contains Tensor.
            dim2 = paddle.to_tensor([3]).astype('int32')
            data3 = paddle.empty(shape=[2, dim2], dtype='float32')
            print(data3)
            # Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
            #        [[ 0.00000000,  0.        , -0.92634487],
            #         [-0.51007903, -0.02454148,  1.29315734]])    # uninitialized
1374 1375 1376 1377 1378 1379 1380
    """

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

    dtype = convert_dtype(dtype)

Z
zhiboniu 已提交
1381
    if paddle.in_dynamic_mode():
1382
        shape = utils.convert_shape_to_list(shape)
W
wanghuancoder 已提交
1383 1384
        out = _C_ops.empty('shape', shape, 'dtype',
                           convert_np_dtype_to_dtype_(dtype))
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
        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
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448


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)

Z
zhiboniu 已提交
1449
    if paddle.in_dynamic_mode():
W
wanghuancoder 已提交
1450 1451
        out = _C_ops.empty('shape', x.shape, 'dtype',
                           convert_np_dtype_to_dtype_(dtype))
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
        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
1479 1480 1481 1482


def assign(x, output=None):
    """
1483

1484 1485 1486
    The OP copies the :attr:`x` to the :attr:`output`.
 
    Parameters:
1487
        x (Tensor|np.ndarray|list|tuple|scalar): A tensor, numpy ndarray, tuple/list of scalar,
1488 1489 1490
            or scalar. Its data type supports float16, float32, float64, int32, int64, and bool.
            Note: the float64 data will be converted to float32 because of current platform protobuf
            data limitation.
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
        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]]
    """
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
    input = x
    helper = LayerHelper('assign', **locals())
    check_type(input, 'input', (Variable, np.ndarray, list, tuple, float, int,
                                bool), 'assign')
    is_inplace = True if output is not None else False

    if np.isscalar(input) and not isinstance(input, str):
        input = np.array([input])
    elif isinstance(input, (list, tuple)):
        input = np.array(input)
    # NOTE(Aurelius84): Why we judge core.VarBase?
    # In case of @to_static, a VarBase can be as input of `assign`,
    # but _non_static_mode()==False under @to_static, which means
    # isinstance(VarBase, Variable) == False. It will cause return None
    # after this api.
    if isinstance(input, (Variable, core.VarBase)):
        if _non_static_mode():
            if output is None:
                if _in_legacy_dygraph():
                    output = core.VarBase()
                else:
                    output = core.eager.Tensor()
            _C_ops.assign(input, output)
        else:
            check_dtype(input.dtype, 'input', [
                'float16', 'uint16', 'float32', 'float64', 'int32', 'int64',
                'uint8', 'bool'
            ], 'assign', '(When the type of input in assign is Variable.)')
            if output is None:
                output = helper.create_variable_for_type_inference(
                    dtype=input.dtype)
            helper.append_op(
                type='assign', inputs={'X': [input]},
                outputs={'Out': [output]})
    elif isinstance(input, np.ndarray):
        # Not support [var, var, ...] currently.
        if len(input.shape) > 0 and any(isinstance(x, Variable) for x in input):
            raise TypeError(
                "Required type(input) numpy.ndarray, but found `list(Variable)` in input."
            )
        dtype = convert_np_dtype_to_dtype_(input.dtype)
        if dtype == core.VarDesc.VarType.FP64:
            # Setting FP64 numpy data is not supported in Paddle, so we
            # use FP32 here
            warnings.warn(
                "paddle.assign doesn't support float64 input now due "
                "to current platform protobuf data limitation, we convert "
                "it to float32")
            dtype = core.VarDesc.VarType.FP32
        if dtype == core.VarDesc.VarType.BOOL:
            value_name = "bool_values"
            values = [int(v) for v in input.flat]
        elif dtype == core.VarDesc.VarType.FP32:
            value_name = "fp32_values"
            values = [float(v) for v in input.flat]
        elif dtype == core.VarDesc.VarType.INT32:
            value_name = "int32_values"
            values = [int(v) for v in input.flat]
        elif dtype == core.VarDesc.VarType.INT64:
            value_name = "int64_values"
            values = [int(v) for v in input.flat]
        else:
            raise TypeError(
                "When the type of 'input' in assign is numpy.ndarray, "
                "the data type of 'input' must be bool, float32, int32 or int64, but "
                "received %s." % convert_dtype(dtype))
        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")
        if output is None:
            output = helper.create_variable_for_type_inference(
                dtype=input.dtype)
        helper.append_op(
            type='assign_value',
            outputs={'Out': [output]},
            attrs={
                'dtype': dtype,
                'shape': list(input.shape),
                value_name: values
            })

    if is_inplace and _non_static_mode():
        output._bump_inplace_version()

    return output
1596 1597


1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
def clone(x, name=None):
    """
    Returns a copy of input Tensor. It will always have a Tensor copy. 
    
    In addition, This function is derivable, so gradients will flow back from the output to input.

    Parameters:
        x (Tensor): The input Tensor.
        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: A Tensor copied from ``input`` .

    Examples:
        .. code-block:: python

            import paddle

            x = paddle.ones([2])
            x.stop_gradient = False
            clone_x = paddle.clone(x)

            y = clone_x**3
            y.backward()
            print(clone_x.grad)          # [3]
            print(x.grad)                # [3]
    """
    return x.clone()


1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
#NOTE(zhiqiu): not public 
def _memcpy(input, place=None, output=None):
    """

    The OP copies the :attr:`input` to the :attr:`output`.
    NOTE: currently, only support CUDAPlace <-> CUDAPinnedPlace or NPUPlace <-> CPUPlace.

    Parameters:
        input (Tensor): A tensor. Its data type supports float16, float32, float64, int32, int64, and bool.
        device (Place): Target place for the output.
        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:`input`.

    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]]
          result = paddle._memcpy(data, place=paddle.CPUPlace())  # result2 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
    """
    helper = LayerHelper('memcpy', **locals())
    check_type(input, 'input', (Variable), 'memcpy')

    if isinstance(input, (Variable, core.VarBase)):
        check_dtype(input.dtype, 'input', [
            'float16', 'uint16', 'float32', 'float64', 'int32', 'int64',
            'uint8', 'bool'
        ], 'memcpy', '(When the type of input in memcpy is Variable.)')
    if output is None:
        output = helper.create_variable_for_type_inference(dtype=input.dtype)

    dst_place_type = -1
    if place is None:
        dst_place_type = -1
    else:
        p = core.Place()
        p.set_place(place)
        if p.is_cpu_place():
            dst_place_type = 0
        elif p.is_gpu_place():
            dst_place_type = 1
        elif p.is_cuda_pinned_place():
            dst_place_type = 2
        elif p.is_xpu_place():
            dst_place_type = 3
        elif p.is_npu_place():
            dst_place_type = 4

    attrs = {'dst_place_type': dst_place_type}
    helper.append_op(
        type='memcpy',
        inputs={'X': [input]},
        outputs={'Out': [output]},
        attrs=attrs)
    return output
F
Feiyu Chan 已提交
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714


def complex(real, imag, name=None):
    """Return a compelx tensor given the real and image component.

    Args:
        real (Tensor): The real component. The data type should be 'float32' or 'float64'.
        imag (Tensor): The image component. The data type should be the same as ``real``.
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

    Returns:
        Tensor: The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``real`` and ``imag``.

    **Note**:
        ``paddle.complex`` supports broadcasting. If you want know more about broadcasting, please refer to :ref:`user_guide_broadcasting` .

    Examples:
        .. code-block:: python

            import paddle
            x = paddle.arange(2, dtype=paddle.float32).unsqueeze(-1)
            y = paddle.arange(3, dtype=paddle.float32)
            z = paddle.complex(x, y)
            print(z.numpy())

            # [[0.+0.j 0.+1.j 0.+2.j]
            #  [1.+0.j 1.+1.j 1.+2.j]]
    """
Z
zhiboniu 已提交
1715
    if paddle.in_dynamic_mode():
F
Feiyu Chan 已提交
1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
        return paddle._C_ops.complex(real, imag)

    check_variable_and_dtype(real, 'real', ['float32', 'float64'], 'complex')
    check_variable_and_dtype(imag, 'imag', ['float32', 'float64'], 'complex')

    op_type = "complex"
    helper = LayerHelper(op_type, **locals())
    inputs = {"X": real, "Y": imag}
    out = helper.create_variable_for_type_inference(
        dtype=_real_to_complex_dtype(real.dtype))
    outputs = {"Out": out}
    attrs = {}
    helper.append_op(type=op_type, inputs=inputs, attrs=attrs, outputs=outputs)
    return out